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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

/// @dev Minimal ERC-20 shape: enough for a pool key and for the hook's buyCap() read.
contract MiniToken {
    uint256 public totalSupply = 1_000_000 ether;
    mapping(address => uint256) public balanceOf;

    constructor() {
        balanceOf[msg.sender] = totalSupply;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }
}

/// @notice Anyone can permanently bind the hook to a worthless pool before the project's pool is created.
/// The deployer can only deploy once, so after the griefing transaction the launch is unusable.
/// Fails on the current code (the project's initialize reverts with AlreadyBound); passes once binding is
/// restricted to the hook's owner or the hook serves more than one pool.
contract BindGriefProof is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    address internal owner = makeAddr("owner");
    address internal griefer = makeAddr("griefer");

    PoolManager internal manager;
    PondsideGuardDeployer internal deployer;
    PondsideGuard internal hook;

    function setUp() public {
        manager = new PoolManager(address(this));
        deployer = new PondsideGuardDeployer(manager, owner, owner);
        bytes32 salt;
        while (!deployer.isValidSalt(salt)) {
            salt = bytes32(uint256(salt) + 1);
        }
        hook = deployer.deploy(salt);
    }

    function _key(address token) internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(token),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
    }

    function test_griefer_cannot_lock_hook_to_junk_pool() public {
        // Step 1: the griefer sees the hook address (predict / PondsideGuardDeployed) and initializes an
        // ETH / junk pool with it first. Whether this reverts or binds is the fix's choice.
        vm.startPrank(griefer, griefer);
        MiniToken junk = new MiniToken();
        try manager.initialize(_key(address(junk)), SQRT_PRICE_1_1) {} catch {}
        vm.stopPrank();

        // Step 2: the hook can never be deployed again from the launch's deployer.
        vm.expectRevert(abi.encodeWithSelector(PondsideGuardDeployer.AlreadyDeployed.selector, address(hook)));
        deployer.deploy(bytes32(uint256(123)));

        // Step 3: the project's own pool must still be able to use the hook. On the current code this reverts
        // with AlreadyBound wrapped by the PoolManager.
        vm.startPrank(owner, owner);
        MiniToken real = new MiniToken();
        manager.initialize(_key(address(real)), SQRT_PRICE_1_1);
        vm.stopPrank();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.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 {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

contract MiniToken {
    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) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }
}

/// @notice An exact-output sell (ETH is the specified currency) that is only partially filled by the price
/// limit is charged 2% of the ETH the trader ASKED for, not of the ETH the pool actually paid out. When the
/// fill is smaller than the fee the seller ends up paying ETH on top of the tokens they sold.
/// Fails on the current code (the seller's ETH balance goes down); passes once the fee is computed from the
/// ETH the pool actually moved.
contract PartialFillFeeProof is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    address internal owner = makeAddr("owner");
    address internal lp = makeAddr("lp");
    address internal alice = makeAddr("alice");

    PoolManager internal manager;
    PoolSwapTest internal swapRouter;
    PoolModifyLiquidityTest internal liquidityRouter;
    MiniToken internal token;
    PondsideGuard internal hook;
    PoolKey internal key;

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        token = new MiniToken();
        token.mint(lp, 1_000_000 ether);
        token.mint(alice, 1_000_000 ether);

        PondsideGuardDeployer deployer = new PondsideGuardDeployer(manager, owner, owner);
        bytes32 salt;
        while (!deployer.isValidSalt(salt)) {
            salt = bytes32(uint256(salt) + 1);
        }
        hook = deployer.deploy(salt);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(lp, 600_000 ether);
        vm.startPrank(lp, lp);
        token.approve(address(liquidityRouter), type(uint256).max);
        liquidityRouter.modifyLiquidity{value: 500_001 ether}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(60),
                tickUpper: TickMath.maxUsableTick(60),
                liquidityDelta: int256(uint256(500_000 ether)),
                salt: 0
            }),
            ""
        );
        vm.stopPrank();

        vm.deal(alice, 10 ether);
        vm.prank(alice);
        token.approve(address(swapRouter), type(uint256).max);
    }

    function test_partial_fill_sell_must_not_cost_the_seller_eth() public {
        uint256 ethBefore = alice.balance;
        uint256 tokensBefore = token.balanceOf(alice);

        // Alice asks for exactly 1 ETH out but caps the price move at ~1e-9 of the current price, so the pool
        // can only pay out about 0.0005 ETH before stopping. The hook still charges 2.04% of the 1 ETH requested.
        uint160 limit = SQRT_PRICE_1_1 + SQRT_PRICE_1_1 / 1_000_000_000;
        vm.startPrank(alice, alice);
        BalanceDelta delta = swapRouter.swap{value: 1 ether}(
            key,
            SwapParams({zeroForOne: false, amountSpecified: int256(1 ether), sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
        vm.stopPrank();

        assertLt(token.balanceOf(alice), tokensBefore, "alice sold tokens");
        emit log_named_int("trader ETH delta (wei)", delta.amount0());
        emit log_named_uint("alice ETH before", ethBefore);
        emit log_named_uint("alice ETH after ", alice.balance);
        // A seller of tokens must never end the swap with less ETH than they started with.
        assertGe(alice.balance, ethBefore, "seller paid ETH for selling tokens");
    }
}

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

import {Test} from "forge-std/Test.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 {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

contract MiniToken {
    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 burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= 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) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// @notice Anyone can bind the hook to any pool before the intended pool is created, and nothing can undo it.
contract BindingFrontRunTest is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    address internal owner = makeAddr("owner");
    address internal attacker = makeAddr("attacker");

    PoolManager internal manager;
    PondsideGuardDeployer internal deployer;
    PondsideGuard internal hook;

    function setUp() public {
        manager = new PoolManager(address(this));
        deployer = new PondsideGuardDeployer(manager, owner, owner);
        bytes32 salt = _mine(address(deployer), deployer.initCodeHash(), deployer.requiredFlags());
        hook = deployer.deploy(salt);
    }

    function _mine(address create2Sender, bytes32 initCodeHash, uint160 flags) internal pure returns (bytes32) {
        for (uint256 i; i < 1_000_000; ++i) {
            address candidate = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), create2Sender, bytes32(i), initCodeHash))))
            );
            if ((uint160(candidate) & Hooks.ALL_HOOK_MASK) == flags) return bytes32(i);
        }
        revert("no salt");
    }

    function _key(address token) internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(token),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
    }

    /// Expected: the hook is "usable by anyone initializing a new pool with it", so the owner's intended
    /// ETH/token pool can be initialized after a stranger used the hook for a different pool.
    /// Actual: the stranger's pool binds the hook forever and the intended pool reverts with AlreadyBound.
    function test_strangerPoolDoesNotBlockIntendedPool() public {
        // 1. A stranger (or a front-runner watching the owner's pending initialize) creates any ETH/junk pool.
        MiniToken junk = new MiniToken();
        vm.prank(attacker, attacker);
        manager.initialize(_key(address(junk)), SQRT_PRICE_1_1);
        assertTrue(hook.bound(), "stranger's pool bound the hook");

        // 2. The owner's real token pool can no longer be created with this hook.
        MiniToken real = new MiniToken();
        real.mint(owner, 1_000_000 ether);
        vm.prank(owner, owner);
        manager.initialize(_key(address(real)), SQRT_PRICE_1_1);

        // 3. A single deployer instance can never produce a replacement hook either.
        assertEq(address(deployer.hook()), address(hook));
    }
}

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

import {Test} from "forge-std/Test.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 {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.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 {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

contract MiniToken {
    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 burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= 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) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// @notice When ETH is the specified currency and the pool cannot fill the whole request, the hook still
/// charges 1% + 1% of the *requested* ETH, not of the ETH side that was actually swapped.
contract PartialFillFeeTest is Test {
    address internal owner = makeAddr("owner");
    address internal recipient = makeAddr("recipient");
    address internal lp = makeAddr("lp");
    address internal alice = makeAddr("alice");

    PoolManager internal manager;
    PoolSwapTest internal swapRouter;
    PoolModifyLiquidityTest internal liquidityRouter;
    MiniToken internal token;
    PondsideGuard internal hook;
    PoolKey internal key;

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        token = new MiniToken();
        token.mint(lp, 1_000_000 ether);

        PondsideGuardDeployer deployer = new PondsideGuardDeployer(manager, owner, recipient);
        bytes32 salt = _mine(address(deployer), deployer.initCodeHash(), deployer.requiredFlags());
        hook = deployer.deploy(salt);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        // Price just above tick 0; the only liquidity sits in [-600, 0], i.e. the pool can absorb ~3 ETH of buys.
        manager.initialize(key, TickMath.getSqrtPriceAtTick(30));

        vm.startPrank(lp, lp);
        token.approve(address(liquidityRouter), type(uint256).max);
        liquidityRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({tickLower: -600, tickUpper: 0, liquidityDelta: int256(100 ether), salt: 0}),
            ""
        );
        vm.stopPrank();

        vm.deal(alice, 100 ether);
    }

    function _mine(address create2Sender, bytes32 initCodeHash, uint160 flags) internal pure returns (bytes32) {
        for (uint256 i; i < 1_000_000; ++i) {
            address candidate = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), create2Sender, bytes32(i), initCodeHash))))
            );
            if ((uint160(candidate) & Hooks.ALL_HOOK_MASK) == flags) return bytes32(i);
        }
        revert("no salt");
    }

    /// Expected: the recipient fee is 1% of the ETH the pool actually took (or the partial fill is refused).
    /// Actual: alice asks to spend 10 ETH, the pool can only take ~3 ETH, and the hook still takes
    /// 0.1 ETH for the recipient and 0.1 ETH for the jar: about 6.5% of the real ETH side.
    function test_partialFillChargesFeeOnFilledEthOnly() public {
        uint256 ethIn = 10 ether;
        vm.startPrank(alice, alice);
        try swapRouter.swap{value: ethIn}(
            key,
            SwapParams({zeroForOne: true, amountSpecified: -int256(ethIn), sqrtPriceLimitX96: TickMath.MIN_SQRT_PRICE + 1}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        ) returns (BalanceDelta delta) {
            vm.stopPrank();
            // Paid directly or minted as a claim: either way it was charged to alice.
            uint256 fee = recipient.balance + hook.pendingFees();
            uint256 jarCut = hook.jar();
            uint256 paid = uint256(uint128(-delta.amount0()));
            uint256 traded = paid - fee - jarCut; // the ETH the pool actually received
            emit log_named_uint("eth requested", ethIn);
            emit log_named_uint("eth actually traded", traded);
            emit log_named_uint("recipient fee", fee);
            emit log_named_uint("jar cut", jarCut);
            assertLt(traded, ethIn / 2, "precondition: the fill was partial");
            assertLe(fee, traded / 100 + 1, "recipient fee must be 1% of the ETH side actually swapped");
            assertLe(jarCut, traded / 100 + 1, "jar cut must be 1% of the ETH side actually swapped");
        } catch {
            // A hook that refuses partial fills of ETH-specified swaps is also an acceptable behaviour.
            vm.stopPrank();
        }
    }
}

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

import {Test} from "forge-std/Test.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 {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

/// @dev Minimal token standing in for the launch token and for a stranger's junk token.
contract MiniToken {
    uint256 public totalSupply = 1_000_000 ether;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {
        balanceOf[msg.sender] = totalSupply;
    }

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

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

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

    function burn(uint256 a) external {
        balanceOf[msg.sender] -= a;
        totalSupply -= a;
    }
}

/// @dev An unprivileged party that tries to bind the hook to a pool of its own before the launch does.
/// The attempt is wrapped so the test does not depend on whether a fixed hook accepts or refuses it.
contract Stranger {
    function tryInitialize(IPoolManager manager, PoolKey memory key) external returns (bool ok) {
        try manager.initialize(key, 79228162514264337593543950336) {
            ok = true;
        } catch {
            ok = false;
        }
    }
}

/// @notice Anyone can permanently bind the hook by being the first to initialize *any* ETH/anything pool with
/// it. The launch's own pool can then never use the hook, and the single-use deployer cannot replace it.
contract BindFrontrunTest is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager internal manager;
    PondsideGuardDeployer internal deployer;
    PondsideGuard internal hook;
    MiniToken internal launchToken;
    address internal owner = makeAddr("owner");

    function setUp() public {
        manager = new PoolManager(address(this));
        deployer = new PondsideGuardDeployer(manager, owner, owner);
        hook = deployer.deploy(_mineSalt());
        launchToken = new MiniToken();
    }

    function _mineSalt() internal view returns (bytes32) {
        bytes32 initHash = deployer.initCodeHash();
        uint160 flags = deployer.requiredFlags();
        for (uint256 i = 0; i < 500_000; ++i) {
            address c = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(deployer), bytes32(i), initHash))))
            );
            if ((uint160(c) & Hooks.ALL_HOOK_MASK) == flags) return bytes32(i);
        }
        revert("no salt");
    }

    function _key(address token) internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(token),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
    }

    /// Fails on the current code: after a stranger's junk pool binds the hook, the launch pool's
    /// `initialize` reverts with `AlreadyBound` (wrapped by the PoolManager) and nothing can undo it.
    /// Passes once the hook serves the launch pool regardless of who initialized a pool with it first
    /// (for example by keeping its per-pool state keyed by PoolId instead of a single `poolKey`).
    function test_launchPoolStillUsableAfterStrangerInitializesFirst() public {
        Stranger stranger = new Stranger();
        MiniToken junk = new MiniToken();
        // The stranger needs no liquidity, no ETH and no permission: one `initialize` call.
        stranger.tryInitialize(manager, _key(address(junk)));

        // The launch's own pool must still be able to use the hook.
        manager.initialize(_key(address(launchToken)), SQRT_PRICE_1_1);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PondsideGuard} from "src/PondsideGuard.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 {Currency} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";

contract ProofToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; totalSupply += amount; }
    function approve(address to, uint256 amount) external returns (bool) { allowance[msg.sender][to] = 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;
    }
    function burn(uint256 amount) external { balanceOf[msg.sender] -= amount; totalSupply -= amount; }
}

// All accounting goes through the unmodified v4 PoolManager; no mocked hook callbacks.
contract ProofRouter {
    IPoolManager public immutable manager;
    constructor(IPoolManager manager_) { manager = manager_; }
    receive() external payable {}
    function add(PoolKey memory key, uint256 liquidity) external payable {
        manager.unlock(abi.encode(msg.sender, key, true, abi.encode(liquidity)));
        _refund();
    }
    function swap(PoolKey memory key, SwapParams memory params) external payable returns (BalanceDelta delta) {
        delta = abi.decode(manager.unlock(abi.encode(msg.sender, key, false, abi.encode(params))), (BalanceDelta));
        _refund();
    }
    function _refund() private {
        (bool ok,) = msg.sender.call{value: address(this).balance}("");
        require(ok);
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address payer, PoolKey memory key, bool adding, bytes memory args) =
            abi.decode(data, (address, PoolKey, bool, bytes));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(abi.decode(args, (uint256))), bytes32(0)
            ), "");
        } else { delta = manager.swap(key, abi.decode(args, (SwapParams)), ""); }
        _settle(key.currency0, delta.amount0(), payer);
        _settle(key.currency1, delta.amount1(), payer);
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta > 0) { manager.take(currency, payer, uint128(delta)); }
        else if (delta < 0) {
            uint256 amount = uint128(-delta);
            manager.sync(currency);
            if (Currency.unwrap(currency) == address(0)) { manager.settle{value: amount}(); }
            else {
                ProofToken(Currency.unwrap(currency)).transferFrom(payer, address(manager), amount);
                manager.settle();
            }
        }
    }
}

contract PartialFillProof is Test {
    uint160 constant PRICE = 79228162514264337593543950336;
    PoolManager manager;
    PondsideGuard hook;
    ProofToken token;
    ProofRouter router;
    PoolKey key;
    address recipient;
    receive() external payable {}
    function setUp() public {
        recipient = makeAddr("recipient");
        manager = new PoolManager(address(this));
        token = new ProofToken();
        router = new ProofRouter(manager);
        bytes32 hash = keccak256(abi.encodePacked(type(PondsideGuard).creationCode,
            abi.encode(manager, address(this), recipient)));
        uint160 flags = Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
            | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        for (uint256 i;; ++i) {
            bytes32 salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) == flags) {
                hook = new PondsideGuard{salt: salt}(manager, address(this), recipient);
                break;
            }
        }
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, PRICE);
        token.mint(address(this), 1_000_000 ether);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1_000_000 ether);
        router.add{value: 500_001 ether}(key, 500_000 ether);
    }

    function test_partialBuyFeeMustBeOnePercentOfActualEthPaid() public {
        uint256 beforeEth = address(this).balance;
        BalanceDelta delta = router.swap{value: 1 ether}(key, SwapParams(true, -1 ether, PRICE - PRICE / 100_000_000));
        uint256 paid = beforeEth - address(this).balance;
        assertGt(delta.amount1(), 0, "a real partial swap occurred");
        assertLt(paid, 0.1 ether, "less than a tenth of the request filled");
        // Expected: <= 1% of actual gross ETH paid. Actual: 0.01 ETH, about 40% of the payment.
        assertLe(recipient.balance, paid / 100, "fee charged on unfilled ETH");
    }

    function test_partialSellMustReceiveEthRatherThanPayBothCurrencies() public {
        uint256 beforeEth = address(this).balance;
        uint256 beforeTokens = token.balanceOf(address(this));
        BalanceDelta delta = router.swap{value: 1 ether}(key, SwapParams(false, 1 ether, PRICE + PRICE / 100_000_000));
        assertLt(token.balanceOf(address(this)), beforeTokens, "tokens sold into the pool");
        // Expected: positive ETH proceeds less a 2% combined fee. Actual: negative ETH proceeds.
        assertGt(delta.amount0(), 0, "partial sell charges ETH as well as tokens");
        assertGt(address(this).balance, beforeEth, "seller must receive ETH");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PondsideGuard} from "src/PondsideGuard.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 {Currency} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";

contract ProofToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; totalSupply += amount; }
    function approve(address to, uint256 amount) external returns (bool) { allowance[msg.sender][to] = 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;
    }
    function burn(uint256 amount) external { balanceOf[msg.sender] -= amount; totalSupply -= amount; }
}

// All accounting goes through the unmodified v4 PoolManager; no mocked hook callbacks.
contract ProofRouter {
    IPoolManager public immutable manager;
    constructor(IPoolManager manager_) { manager = manager_; }
    receive() external payable {}
    function add(PoolKey memory key, uint256 liquidity) external payable {
        manager.unlock(abi.encode(msg.sender, key, true, abi.encode(liquidity)));
        _refund();
    }
    function swap(PoolKey memory key, SwapParams memory params) external payable returns (BalanceDelta delta) {
        delta = abi.decode(manager.unlock(abi.encode(msg.sender, key, false, abi.encode(params))), (BalanceDelta));
        _refund();
    }
    function _refund() private {
        (bool ok,) = msg.sender.call{value: address(this).balance}("");
        require(ok);
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address payer, PoolKey memory key, bool adding, bytes memory args) =
            abi.decode(data, (address, PoolKey, bool, bytes));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(abi.decode(args, (uint256))), bytes32(0)
            ), "");
        } else { delta = manager.swap(key, abi.decode(args, (SwapParams)), ""); }
        _settle(key.currency0, delta.amount0(), payer);
        _settle(key.currency1, delta.amount1(), payer);
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta > 0) { manager.take(currency, payer, uint128(delta)); }
        else if (delta < 0) {
            uint256 amount = uint128(-delta);
            manager.sync(currency);
            if (Currency.unwrap(currency) == address(0)) { manager.settle{value: amount}(); }
            else {
                ProofToken(Currency.unwrap(currency)).transferFrom(payer, address(manager), amount);
                manager.settle();
            }
        }
    }
}

contract WalletCapProof is Test {
    uint160 constant PRICE = 79228162514264337593543950336;
    PoolManager manager;
    PondsideGuard hook;
    ProofToken token;
    ProofRouter router;
    PoolKey key;
    address recipient;
    receive() external payable {}
    function setUp() public {
        recipient = makeAddr("recipient");
        manager = new PoolManager(address(this));
        token = new ProofToken();
        router = new ProofRouter(manager);
        bytes32 hash = keccak256(abi.encodePacked(type(PondsideGuard).creationCode,
            abi.encode(manager, address(this), recipient)));
        uint160 flags = Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
            | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        for (uint256 i;; ++i) {
            bytes32 salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) == flags) {
                hook = new PondsideGuard{salt: salt}(manager, address(this), recipient);
                break;
            }
        }
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, PRICE);
        token.mint(address(this), 1_000_000 ether);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1_000_000 ether);
        router.add{value: 500_001 ether}(key, 500_000 ether);
    }

    function test_sameSmartWalletCannotBuyOverCapThroughDifferentAuthorizedSigners() public {
        address signerA = makeAddr("signer A");
        address signerB = makeAddr("signer B");
        ProofWallet wallet = new ProofWallet(router, signerA, signerB);
        vm.deal(address(wallet), 30_000 ether);
        uint256 capAtOpen = token.totalSupply() / 100;
        vm.prank(signerA, signerA);
        wallet.buy(key, 6_000 ether);
        assertEq(token.balanceOf(address(wallet)), 6_000 ether);
        vm.prank(signerB, signerB);
        (bool secondBuy,) = address(wallet).call(abi.encodeCall(wallet.buy, (key, 6_000 ether)));
        assertFalse(secondBuy, "same wallet exceeded its cumulative cap by changing the submitting signer");
        assertLe(token.balanceOf(address(wallet)), capAtOpen);
    }
}

contract ProofWallet {
    ProofRouter immutable router;
    address immutable signerA;
    address immutable signerB;
    constructor(ProofRouter r, address a, address b) { router = r; signerA = a; signerB = b; }
    receive() external payable {}
    function buy(PoolKey memory key, uint256 tokensOut) external {
        require(msg.sender == signerA || msg.sender == signerB, "only authorized signers");
        router.swap{value: 10_000 ether}(key, SwapParams(true, int256(tokensOut), TickMath.MIN_SQRT_PRICE + 1));
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PondsideGuard} from "src/PondsideGuard.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 {Currency} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";

contract ProofToken {
    bool public burnFails;
    function setBurnFailure(bool value) external { burnFails = value; }
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; totalSupply += amount; }
    function approve(address to, uint256 amount) external returns (bool) { allowance[msg.sender][to] = 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;
    }
    function burn(uint256 amount) external { require(!burnFails, "burn temporarily unavailable"); balanceOf[msg.sender] -= amount; totalSupply -= amount; }
}

// All accounting goes through the unmodified v4 PoolManager; no mocked hook callbacks.
contract ProofRouter {
    IPoolManager public immutable manager;
    constructor(IPoolManager manager_) { manager = manager_; }
    receive() external payable {}
    function add(PoolKey memory key, uint256 liquidity) external payable {
        manager.unlock(abi.encode(msg.sender, key, true, abi.encode(liquidity)));
        _refund();
    }
    function swap(PoolKey memory key, SwapParams memory params) external payable returns (BalanceDelta delta) {
        delta = abi.decode(manager.unlock(abi.encode(msg.sender, key, false, abi.encode(params))), (BalanceDelta));
        _refund();
    }
    function _refund() private {
        (bool ok,) = msg.sender.call{value: address(this).balance}("");
        require(ok);
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address payer, PoolKey memory key, bool adding, bytes memory args) =
            abi.decode(data, (address, PoolKey, bool, bytes));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(abi.decode(args, (uint256))), bytes32(0)
            ), "");
        } else { delta = manager.swap(key, abi.decode(args, (SwapParams)), ""); }
        _settle(key.currency0, delta.amount0(), payer);
        _settle(key.currency1, delta.amount1(), payer);
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta > 0) { manager.take(currency, payer, uint128(delta)); }
        else if (delta < 0) {
            uint256 amount = uint128(-delta);
            manager.sync(currency);
            if (Currency.unwrap(currency) == address(0)) { manager.settle{value: amount}(); }
            else {
                ProofToken(Currency.unwrap(currency)).transferFrom(payer, address(manager), amount);
                manager.settle();
            }
        }
    }
}

contract BurnFailureProof is Test {
    uint160 constant PRICE = 79228162514264337593543950336;
    PoolManager manager;
    PondsideGuard hook;
    ProofToken token;
    ProofRouter router;
    PoolKey key;
    address recipient;
    receive() external payable {}
    function setUp() public {
        recipient = makeAddr("recipient");
        manager = new PoolManager(address(this));
        token = new ProofToken();
        router = new ProofRouter(manager);
        bytes32 hash = keccak256(abi.encodePacked(type(PondsideGuard).creationCode,
            abi.encode(manager, address(this), recipient)));
        uint160 flags = Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
            | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        for (uint256 i;; ++i) {
            bytes32 salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) == flags) {
                hook = new PondsideGuard{salt: salt}(manager, address(this), recipient);
                break;
            }
        }
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, PRICE);
        token.mint(address(this), 1_000_000 ether);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1_000_000 ether);
        router.add{value: 500_001 ether}(key, 500_000 ether);
    }

    function test_failedBurnMustRollBackBuybackAndLeaveJarRetryable() public {
        token.setBurnFailure(true);
        uint256 supplyBefore = token.totalSupply();
        router.swap{value: 10 ether}(key, SwapParams(true, -10 ether, TickMath.MIN_SQRT_PRICE + 1));
        // The outer trade succeeds, but its automatic buy-and-burn cannot complete.
        assertEq(token.totalSupply(), supplyBefore);
        assertEq(hook.jar(), 0.1 ether, "failed burn consumed jar instead of leaving a retryable buyback");
        assertEq(token.balanceOf(address(hook)), 0, "failed buyback should roll back its token purchase");
        token.setBurnFailure(false);
        hook.buyback();
        assertEq(hook.jar(), 0);
        assertGt(hook.totalBurned(), 0);
        assertLt(token.totalSupply(), supplyBefore);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

/// @dev Minimal ERC-20 shape: enough for a pool key and for the hook's buyCap() read.
contract MiniToken {
    uint256 public totalSupply = 1_000_000 ether;
    mapping(address => uint256) public balanceOf;

    constructor() {
        balanceOf[msg.sender] = totalSupply;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }
}

/// @notice Anyone can permanently bind the hook to a worthless pool before the project's pool is created.
/// The deployer can only deploy once, so after the griefing transaction the launch is unusable.
/// Fails on the current code (the project's initialize reverts with AlreadyBound); passes once binding is
/// restricted to the hook's owner or the hook serves more than one pool.
contract BindGriefProof is Test {
    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    address internal owner = makeAddr("owner");
    address internal griefer = makeAddr("griefer");

    PoolManager internal manager;
    PondsideGuardDeployer internal deployer;
    PondsideGuard internal hook;

    function setUp() public {
        manager = new PoolManager(address(this));
        deployer = new PondsideGuardDeployer(manager, owner, owner);
        bytes32 salt;
        while (!deployer.isValidSalt(salt)) {
            salt = bytes32(uint256(salt) + 1);
        }
        hook = deployer.deploy(salt);
    }

    function _key(address token) internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(token),
            fee: 3000,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
    }

    function test_griefer_cannot_lock_hook_to_junk_pool() public {
        // Step 1: the griefer sees the hook address (predict / PondsideGuardDeployed) and initializes an
        // ETH / junk pool with it first. Whether this reverts or binds is the fix's choice.
        vm.startPrank(griefer, griefer);
        MiniToken junk = new MiniToken();
        try manager.initialize(_key(address(junk)), SQRT_PRICE_1_1) {} catch {}
        vm.stopPrank();

        // Step 2: the hook can never be deployed again from the launch's deployer.
        vm.expectRevert(abi.encodeWithSelector(PondsideGuardDeployer.AlreadyDeployed.selector, address(hook)));
        deployer.deploy(bytes32(uint256(123)));

        // Step 3: the project's own pool must still be able to use the hook. On the current code this reverts
        // with AlreadyBound wrapped by the PoolManager.
        vm.startPrank(owner, owner);
        MiniToken real = new MiniToken();
        manager.initialize(_key(address(real)), SQRT_PRICE_1_1);
        vm.stopPrank();
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PondsideGuard} from "src/PondsideGuard.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 {Currency} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {BalanceDelta} from "v4-core/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/types/PoolOperation.sol";

contract ProofToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 amount) external { balanceOf[to] += amount; totalSupply += amount; }
    function approve(address to, uint256 amount) external returns (bool) { allowance[msg.sender][to] = 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;
    }
    function burn(uint256 amount) external { balanceOf[msg.sender] -= amount; totalSupply -= amount; }
}

// All accounting goes through the unmodified v4 PoolManager; no mocked hook callbacks.
contract ProofRouter {
    IPoolManager public immutable manager;
    constructor(IPoolManager manager_) { manager = manager_; }
    receive() external payable {}
    function add(PoolKey memory key, uint256 liquidity) external payable {
        manager.unlock(abi.encode(msg.sender, key, true, abi.encode(liquidity)));
        _refund();
    }
    function swap(PoolKey memory key, SwapParams memory params) external payable returns (BalanceDelta delta) {
        delta = abi.decode(manager.unlock(abi.encode(msg.sender, key, false, abi.encode(params))), (BalanceDelta));
        _refund();
    }
    function _refund() private {
        (bool ok,) = msg.sender.call{value: address(this).balance}("");
        require(ok);
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address payer, PoolKey memory key, bool adding, bytes memory args) =
            abi.decode(data, (address, PoolKey, bool, bytes));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(
                TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(abi.decode(args, (uint256))), bytes32(0)
            ), "");
        } else { delta = manager.swap(key, abi.decode(args, (SwapParams)), ""); }
        _settle(key.currency0, delta.amount0(), payer);
        _settle(key.currency1, delta.amount1(), payer);
        return abi.encode(delta);
    }
    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta > 0) { manager.take(currency, payer, uint128(delta)); }
        else if (delta < 0) {
            uint256 amount = uint128(-delta);
            manager.sync(currency);
            if (Currency.unwrap(currency) == address(0)) { manager.settle{value: amount}(); }
            else {
                ProofToken(Currency.unwrap(currency)).transferFrom(payer, address(manager), amount);
                manager.settle();
            }
        }
    }
}

contract PartialFillProof is Test {
    uint160 constant PRICE = 79228162514264337593543950336;
    PoolManager manager;
    PondsideGuard hook;
    ProofToken token;
    ProofRouter router;
    PoolKey key;
    address recipient;
    receive() external payable {}
    function setUp() public {
        recipient = makeAddr("recipient");
        manager = new PoolManager(address(this));
        token = new ProofToken();
        router = new ProofRouter(manager);
        bytes32 hash = keccak256(abi.encodePacked(type(PondsideGuard).creationCode,
            abi.encode(manager, address(this), recipient)));
        uint160 flags = Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
            | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG;
        for (uint256 i;; ++i) {
            bytes32 salt = bytes32(i);
            address predicted = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if ((uint160(predicted) & Hooks.ALL_HOOK_MASK) == flags) {
                hook = new PondsideGuard{salt: salt}(manager, address(this), recipient);
                break;
            }
        }
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, PRICE);
        token.mint(address(this), 1_000_000 ether);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1_000_000 ether);
        router.add{value: 500_001 ether}(key, 500_000 ether);
    }

    function test_partialBuyFeeMustBeOnePercentOfActualEthPaid() public {
        uint256 beforeEth = address(this).balance;
        BalanceDelta delta = router.swap{value: 1 ether}(key, SwapParams(true, -1 ether, PRICE - PRICE / 100_000_000));
        uint256 paid = beforeEth - address(this).balance;
        assertGt(delta.amount1(), 0, "a real partial swap occurred");
        assertLt(paid, 0.1 ether, "less than a tenth of the request filled");
        // Expected: <= 1% of actual gross ETH paid. Actual: 0.01 ETH, about 40% of the payment.
        assertLe(recipient.balance, paid / 100, "fee charged on unfilled ETH");
    }

    function test_partialSellMustReceiveEthRatherThanPayBothCurrencies() public {
        uint256 beforeEth = address(this).balance;
        uint256 beforeTokens = token.balanceOf(address(this));
        BalanceDelta delta = router.swap{value: 1 ether}(key, SwapParams(false, 1 ether, PRICE + PRICE / 100_000_000));
        assertLt(token.balanceOf(address(this)), beforeTokens, "tokens sold into the pool");
        // Expected: positive ETH proceeds less a 2% combined fee. Actual: negative ETH proceeds.
        assertGt(delta.amount0(), 0, "partial sell charges ETH as well as tokens");
        assertGt(address(this).balance, beforeEth, "seller must receive ETH");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/PoolManager.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 {Currency, CurrencyLibrary} from "v4-core/types/Currency.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/types/PoolId.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 {PondsideGuard} from "src/PondsideGuard.sol";
import {PondsideGuardDeployer} from "src/PondsideGuardDeployer.sol";

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) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }
}

/// A dust swap on a pool that has no liquidity yet starts the buy-cap window; once liquidity arrives more than
/// ten minutes later, the first real buyers are not capped at all.
contract WindowOpenedByEmptySwapProof is Test {
    using PoolIdLibrary for PoolKey;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    function test_capMustApplyToTheFirstRealTradingAfterAnEmptyPoolDustSwap() public {
        PoolManager manager = new PoolManager(address(this));
        PoolSwapTest swapRouter = new PoolSwapTest(manager);
        PoolModifyLiquidityTest liquidityRouter = new PoolModifyLiquidityTest(manager);
        PondsideGuardDeployer d = new PondsideGuardDeployer(manager, makeAddr("owner"), makeAddr("recipient"));
        bytes32 salt;
        for (uint256 i;; ++i) {
            if (d.isValidSalt(bytes32(i))) {
                salt = bytes32(i);
                break;
            }
        }
        PondsideGuard hook = d.deploy(salt);

        ProofToken token = new ProofToken();
        address lp = makeAddr("lp");
        address griefer = makeAddr("griefer");
        address sniper = makeAddr("sniper");
        token.mint(lp, 1_000_000 ether);
        PoolKey memory key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_PRICE_1_1);

        // Before any liquidity exists, a 1-wei buy that fills nothing opens the window.
        vm.deal(griefer, 1 ether);
        vm.prank(griefer, griefer);
        swapRouter.swap{value: 1}(
            key,
            SwapParams({zeroForOne: true, amountSpecified: -1, sqrtPriceLimitX96: SQRT_PRICE_1_1 - 1}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );

        // Liquidity is added 10 minutes later: trading really starts now.
        vm.warp(block.timestamp + 10 minutes);
        vm.deal(lp, 600_000 ether);
        vm.startPrank(lp, lp);
        token.approve(address(liquidityRouter), type(uint256).max);
        liquidityRouter.modifyLiquidity{value: 501_000 ether}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(60),
                tickUpper: TickMath.maxUsableTick(60),
                liquidityDelta: int256(500_000 ether),
                salt: 0
            }),
            ""
        );
        vm.stopPrank();

        // Expected: the first buyer is limited to 1% of supply (10,000 tokens). Actual: 50,000 tokens go through.
        uint256 cap = hook.buyCap(key.toId());
        vm.deal(sniper, 200_000 ether);
        vm.prank(sniper, sniper);
        vm.expectRevert();
        swapRouter.swap{value: 100_000 ether}(
            key,
            SwapParams({zeroForOne: true, amountSpecified: int256(cap * 5), sqrtPriceLimitX96: TickMath.MIN_SQRT_PRICE + 1}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }
}