// 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 {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {LPFeeLibrary} from "v4-core/src/libraries/LPFeeLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidToken} from "src/SigmoidToken.sol";
import {FixedSupplyERC20} from "src/FixedSupplyERC20.sol";
import {HookMiner} from "src/HookMiner.sol";

/// Finding: the surcharge on an exact-output swap is computed as `surcharge x input` and ADDED to the input, so
/// its share of what the trader pays is s/(1+s): at the 89.7% cap an exact-output swap pays 47.3% of its input
/// to the treasury, while an exact-input swap with the identical price move pays 89.7% of its output.
/// Fails now (effective surcharge 472_851 pips); passes once the exact-output surcharge is scaled so that the
/// fee is the same share of the gross amount in both shapes (fee = input x s / (1 - s)).
contract ProofExactOutputFeeTest is Test {
    using PoolIdLibrary for PoolKey;

    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    FixedSupplyERC20 imd;
    SigmoidToken token;
    SigmoidIMD hook;
    address treasury = makeAddr("treasury");
    PoolKey key;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new FixedSupplyERC20("IMD", "IMD");
        token = new SigmoidToken();
        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);

        imd.approve(address(swapRouter), type(uint256).max);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);

        tokenIs0 = address(token) < address(imd);
        key = PoolKey({
            currency0: Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            currency1: Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(60),
                tickUpper: TickMath.maxUsableTick(60),
                liquidityDelta: int256(5e26),
                salt: bytes32(0)
            }),
            ""
        );
        // Outside the window: only the dynamic fee applies.
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
    }

    function _swap(int256 amountSpecified) internal returns (BalanceDelta) {
        bool zeroForOne = !tokenIs0; // IMD in, token out
        return swapRouter.swap(
            key,
            SwapParams({
                zeroForOne: zeroForOne,
                amountSpecified: amountSpecified,
                sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function _abs(int128 x) internal pure returns (uint256) {
        return x < 0 ? uint256(uint128(-x)) : uint256(uint128(x));
    }

    function test_exactOutputBuyPaysSameShareAsExactInputBuy() public {
        uint256 snap = vm.snapshotState();

        // Exact-input buy of 1e25 IMD: price moves ~4%, surcharge capped at 89.7% of the token output.
        BalanceDelta d1 = _swap(-int256(1e25));
        uint256 netTokens = uint256(uint128(tokenIs0 ? d1.amount0() : d1.amount1()));
        uint256 feeTokens = token.balanceOf(treasury);
        uint256 grossTokens = netTokens + feeTokens;
        uint256 exactInPips = feeTokens * 1e6 / grossTokens;
        assertEq(exactInPips, 896_999, "exact input pays the capped 89.7% of its gross output");

        vm.revertToState(snap);

        // Exact-output buy of the same gross token amount: identical pool move, surcharge now on the IMD input.
        BalanceDelta d2 = _swap(int256(grossTokens));
        uint256 imdPaid = _abs(tokenIs0 ? d2.amount1() : d2.amount0());
        uint256 feeImd = imd.balanceOf(treasury);
        uint256 exactOutPips = feeImd * 1e6 / imdPaid;

        // 1e25 IMD at 89.7% -> trader pays 1.897e25 and the treasury gets 0.897e25: 47.3% of what was paid.
        assertGe(exactOutPips, 890_000, "exact output must pay the same share of what the trader pays");
    }
}

// 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 {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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 {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {LPFeeLibrary} from "v4-core/src/libraries/LPFeeLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidToken} from "src/SigmoidToken.sol";
import {FixedSupplyERC20} from "src/FixedSupplyERC20.sol";
import {HookMiner} from "src/HookMiner.sol";

/// Finding: the price impact that sets the surcharge is measured per swap against a reference that is reset
/// after every swap (`lastSettledSqrtPriceX96`), so one trade split into N swaps in the same transaction pays
/// roughly 1/N of the surcharge of the single swap for the same total price move. Outside the window nothing
/// limits N. Fails now (100 x 1e23 IMD pays 0.58e24 tokens of surcharge where 1 x 1e25 pays 8.77e24); passes
/// once the impact is measured against a reference that is not reset inside the same block.
contract ProofSplitSwapsTest is Test {
    using PoolIdLibrary for PoolKey;

    uint160 internal constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    FixedSupplyERC20 imd;
    SigmoidToken token;
    SigmoidIMD hook;
    address treasury = makeAddr("treasury");
    PoolKey key;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new FixedSupplyERC20("IMD", "IMD");
        token = new SigmoidToken();
        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);

        imd.approve(address(swapRouter), type(uint256).max);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);

        tokenIs0 = address(token) < address(imd);
        key = PoolKey({
            currency0: Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            currency1: Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(60),
                tickUpper: TickMath.maxUsableTick(60),
                liquidityDelta: int256(5e26),
                salt: bytes32(0)
            }),
            ""
        );
        // Outside the window: no cooldown, no cap, no breaker; only the dynamic fee remains.
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
    }

    function _buyExactIn(uint256 imdIn) internal returns (uint256 tokensOut) {
        bool zeroForOne = !tokenIs0; // IMD in, token out
        BalanceDelta d = swapRouter.swap(
            key,
            SwapParams({
                zeroForOne: zeroForOne,
                amountSpecified: -int256(imdIn),
                sqrtPriceLimitX96: zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
        tokensOut = uint256(uint128(tokenIs0 ? d.amount0() : d.amount1()));
    }

    function test_splitBuyPaysNoLessSurchargeThanSingleBuy() public {
        uint256 snap = vm.snapshotState();

        // One swap: 1e25 IMD in, price moves ~4%, surcharge capped at 89.7% of the output.
        uint256 netSingle = _buyExactIn(1e25);
        uint256 feeSingle = token.balanceOf(treasury);
        assertGt(feeSingle, netSingle * 8, "single swap: treasury takes ~8.7x what the trader keeps");

        vm.revertToState(snap);

        // Same 1e25 IMD as 100 swaps of 1e23 in the same transaction: each measures ~0.04% impact.
        uint256 netSplit;
        for (uint256 i = 0; i < 100; i++) {
            netSplit += _buyExactIn(1e23);
        }
        uint256 feeSplit = token.balanceOf(treasury);

        // The trader keeps ~9.2e24 tokens instead of ~1.0e24 and the treasury gets ~0.58e24 instead of ~8.77e24.
        assertGe(feeSplit, feeSingle * 9 / 10, "splitting the trade must not cut the surcharge");
        assertLe(netSplit, netSingle * 11 / 10, "splitting the trade must not multiply the trader's output");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

contract ImdMock is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice A swap that fills nothing (the launchpad pool is single-sided, so one side has no liquidity) still moves
/// the pool price, and the hook settles that price as if a trade had happened. Anyone can therefore move the
/// settled price for free: inside the window this trips the circuit breaker for every real buy (launch DoS),
/// outside it the next buyer pays the maximum surcharge.
contract ZeroFillPushTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest router;
    ImdMock imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new ImdMock();

        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);
        assertEq(address(hook), predicted);

        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);
        imd.approve(address(router), type(uint256).max);

        // Launch exactly as the launchpad's own tests do: whole supply single-sided on the token side of 1:1.
        address nextToken = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextTokenIs0 = nextToken < address(imd);
        (int24 lower, int24 upper) = nextTokenIs0 ? (int24(0), int24(887_220)) : (int24(-887_220), int24(0));
        (, token, key) = launchpad.launch("Fair Coin", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;
        IERC20(token).approve(address(router), type(uint256).max);
    }

    function _sqrtPrice() internal view returns (uint160 p) {
        (p,,,) = IPoolManager(address(manager)).getSlot0(poolId);
    }

    function _tokenDelta(BalanceDelta d) internal view returns (int128) {
        return tokenIs0 ? d.amount0() : d.amount1();
    }

    /// @dev A "sell" of 1 wei of the launch token from `origin` with a price limit `bps` basis points of sqrt price
    /// away, into the side of the pool that holds no liquidity. Nothing is filled, nothing is paid; only the price
    /// moves. Failures are swallowed so that a fixed hook that refuses such swaps still passes the test.
    function _push(address origin, uint256 bps) internal {
        uint160 cur = _sqrtPrice();
        uint160 limit = tokenIs0 ? uint160(uint256(cur) * 10_000 / bps) : uint160(uint256(cur) * bps / 10_000);
        if (limit <= TickMath.MIN_SQRT_PRICE) limit = TickMath.MIN_SQRT_PRICE + 1;
        if (limit >= TickMath.MAX_SQRT_PRICE) limit = TickMath.MAX_SQRT_PRICE - 1;
        vm.prank(address(this), origin);
        try router.swap(
            key,
            SwapParams({zeroForOne: tokenIs0, amountSpecified: -1, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        ) {} catch {}
    }

    function _buy(address origin, int256 amountSpecified) internal returns (BalanceDelta) {
        vm.prank(address(this), origin);
        return router.swap(
            key,
            SwapParams({
                zeroForOne: !tokenIs0,
                amountSpecified: amountSpecified,
                sqrtPriceLimitX96: !tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    /// @notice Inside the window: two attacker wallets each move the price 24% (under the 25% breaker) for free.
    /// Alice's ordinary buy of 0.1% of the supply must still go through; on the current hook it reverts with
    /// CircuitBreaker because the settled price is now 1.54x away from the liquidity.
    function test_buyInsideWindowSurvivesZeroFillPushes() public {
        uint256 attackerTokensBefore = IERC20(token).balanceOf(address(this));
        _push(address(0xA1), 11_135); // sqrt ratio 1.1135 -> price ratio 1.24
        _push(address(0xA2), 11_135);
        assertEq(IERC20(token).balanceOf(address(this)), attackerTokensBefore, "the pushes cost the attacker nothing");

        BalanceDelta d = _buy(alice, int256(1e24));
        assertEq(uint256(uint128(_tokenDelta(d))), 1e24, "alice bought 0.1% of the supply inside the window");
    }

    /// @notice Outside the window: one free push far into the empty side. Alice's exact-input buy of 1e24 IMD then
    /// measures a huge "impact" and loses the maximum surcharge (89.7% of her tokens) to the treasury, although
    /// her trade moved the pool price from the liquidity edge by far less than that.
    function test_buyOutsideWindowIsNotSurchargedForAFreePush() public {
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
        _push(address(0xA1), 30_000); // sqrt ratio 3 -> price ratio 9, no breaker outside the window

        BalanceDelta d = _buy(alice, -int256(1e24));
        uint256 net = uint256(uint128(_tokenDelta(d)));
        uint256 fee = IERC20(token).balanceOf(treasury);
        assertLt(fee * 10, net + fee, "the surcharge on an ordinary buy is far below 10% of the output");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

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

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

/// @notice A swap that exchanges nothing can move the pool price through empty liquidity, and the hook
/// settles that price. The next trader's surcharge is measured from the parked price and jumps to the cap.
contract PricePark is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest router;
    ParkMockERC20 imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    address mallory = makeAddr("mallory");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new ParkMockERC20();
        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);
        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);

        address predicted = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextIs0 = predicted < address(imd);
        (int24 lower, int24 upper) = nextIs0 ? (int24(0), int24(887_220)) : (int24(-887_220), int24(0));
        (, token, key) = launchpad.launch("Fair", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;

        imd.mint(address(this), 1e30);
        imd.approve(address(router), type(uint256).max);
        IERC20(token).approve(address(router), type(uint256).max);
    }

    function _swap(address origin, bool zeroForOne, int256 amount, uint160 limit) internal returns (BalanceDelta) {
        vm.prank(address(this), origin);
        return router.swap(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amount, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    /// @dev IMD in, exact 1e23 tokens out. Returns the IMD the trader paid, hook surcharge included.
    function _victimBuy() internal returns (uint256 paid) {
        uint256 before = imd.balanceOf(address(this));
        _swap(alice, !tokenIs0, 1e23, !tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1);
        paid = before - imd.balanceOf(address(this));
    }

    function test_freePricePark_inflatesNextTradersSurchargeToTheCap() public {
        assertTrue(hook.inOpeningWindow(poolId));

        uint256 snapshot = vm.snapshotState();
        uint256 baseline = _victimBuy();
        vm.revertToState(snapshot);

        // Mallory "sells" 1 wei of the token towards the empty side of the single-sided range, with a price
        // limit 24% away in price. No liquidity is there, so nothing is exchanged, but the pool price moves to
        // the limit and the hook settles it. Inside the window the move stays under the 25% breaker.
        (uint160 sqrtBefore,,,) = IPoolManager(address(manager)).getSlot0(poolId);
        uint160 parked = tokenIs0 ? uint160(uint256(sqrtBefore) * 9165 / 10_000) : uint160(uint256(sqrtBefore) * 11_135 / 10_000);
        uint256 tokBefore = IERC20(token).balanceOf(address(this));
        uint256 imdBefore = imd.balanceOf(address(this));
        _swap(mallory, tokenIs0, -1, parked);
        assertEq(IERC20(token).balanceOf(address(this)), tokBefore, "the park cost no token");
        assertEq(imd.balanceOf(address(this)), imdBefore, "the park cost no IMD");
        (uint160 sqrtAfter,,,) = IPoolManager(address(manager)).getSlot0(poolId);
        assertEq(sqrtAfter, parked, "the pool price was parked");
        assertEq(hook.launches(poolId).lastSettledSqrtPriceX96, parked, "the hook settled the parked price");

        // Alice's identical buy now pays the capped surcharge although the trade itself is tiny.
        uint256 attacked = _victimBuy();
        emit log_named_uint("baseline IMD paid ", baseline);
        emit log_named_uint("after park IMD paid", attacked);
        assertLe(attacked, baseline * 105 / 100, "a zero-value swap must not change what the next trader pays");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {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 {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {LPFeeLibrary} from "v4-core/src/libraries/LPFeeLibrary.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {HookMiner} from "src/HookMiner.sol";

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

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

/// @notice The surcharge is a fraction of the unspecified amount. On an exact-input swap that is `s` of what the
/// trader would receive, so a capped swap keeps 10.3%. On an exact-output swap it is `s` of the input, so the
/// trader pays 1.897x and the treasury's share of the payment is only 47%. The same tokens cost far less bought
/// exact-output than exact-input.
contract ExactOutputFee is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest router;
    PoolModifyLiquidityTest lpRouter;
    FeeMockERC20 imd;
    FeeMockERC20 token;
    SigmoidIMD hook;
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");
    PoolKey key;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        imd = new FeeMockERC20("IMD");
        token = new FeeMockERC20("TOK");
        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);

        imd.mint(address(this), 1e30);
        token.mint(address(this), 1e30);
        imd.approve(address(router), type(uint256).max);
        imd.approve(address(lpRouter), type(uint256).max);
        token.approve(address(router), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);

        tokenIs0 = address(token) < address(imd);
        key = PoolKey({
            currency0: Currency.wrap(tokenIs0 ? address(token) : address(imd)),
            currency1: Currency.wrap(tokenIs0 ? address(imd) : address(token)),
            fee: LPFeeLibrary.DYNAMIC_FEE_FLAG,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);
        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams({tickLower: -887_220, tickUpper: 887_220, liquidityDelta: 1e26, salt: bytes32(0)}),
            ""
        );
        // Outside the window: only the dynamic fee applies.
        vm.roll(block.number + 100);
    }

    function _buy(int256 amount) internal {
        vm.prank(address(this), alice);
        router.swap(
            key,
            SwapParams({
                zeroForOne: !tokenIs0,
                amountSpecified: amount,
                sqrtPriceLimitX96: !tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_exactOutputBuyPaysLessThanHalfTheCappedFee() public {
        uint256 want = 1e25; // 10% of the liquidity: impact far past the 0.598% where the 90% cap binds
        uint256 snapshot = vm.snapshotState();

        // Exact output: receive `want` tokens, pay IMD plus the surcharge on the IMD input.
        uint256 imdBefore = imd.balanceOf(address(this));
        _buy(int256(want));
        uint256 paidExactOut = imdBefore - imd.balanceOf(address(this));
        uint256 feeExactOut = imd.balanceOf(treasury);
        assertEq(hook.surchargePips(hook.priceImpactPips(SQRT_PRICE_1_1, _sqrtPrice())), 897_000, "cap binds");
        vm.revertToState(snapshot);

        // Exact input: find the IMD input that nets `want` tokens after the surcharge on the output.
        uint256 lo = 1;
        uint256 hi = 1e29;
        for (uint256 i = 0; i < 80; i++) {
            uint256 mid = (lo + hi) / 2;
            uint256 inner = vm.snapshotState();
            uint256 tokBefore = token.balanceOf(address(this));
            _buy(-int256(mid));
            uint256 got = token.balanceOf(address(this)) - tokBefore;
            vm.revertToState(inner);
            if (got >= want) hi = mid;
            else lo = mid + 1;
        }
        uint256 paidExactIn = hi;

        emit log_named_uint("IMD paid, exact output", paidExactOut);
        emit log_named_uint("IMD paid, exact input ", paidExactIn);
        emit log_named_uint("treasury share of exact-output payment (pips)", feeExactOut * 1e6 / paidExactOut);
        // At the cap the treasury must take 89.7% of what the trader pays, however the swap is shaped.
        assertGe(feeExactOut * 1e6 / paidExactOut, 890_000, "exact-output swaps escape most of the capped surcharge");
    }

    function _sqrtPrice() internal view returns (uint160 p) {
        (p,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

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

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

/// @notice A swap that trades nothing (it only slides the pool price through the empty side of the
/// single-sided launch pool) must not change what the next honest trader pays or whether they can trade.
contract AnchorSlideTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant MAX_TICK = 887_220;
    int24 constant MIN_TICK = -887_220;

    PoolManager manager;
    PoolSwapTest router;
    PairMock imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address attacker = makeAddr("attacker");
    address honest = makeAddr("honest");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new PairMock();
        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);
        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);

        address predicted = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextIs0 = predicted < address(imd);
        (int24 lower, int24 upper) = nextIs0 ? (int24(0), MAX_TICK) : (MIN_TICK, int24(0));
        (, token, key) = launchpad.launch("Fair", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;

        imd.mint(address(this), 1e30);
        imd.approve(address(router), type(uint256).max);
    }

    /// @dev Pushes the price toward the empty (pair) side of the launch range with a 1-wei "sell" of the token,
    /// stopping at `limit`. The attacker holds no tokens: nothing is traded, so nothing is settled.
    function _slide(uint160 limit) internal returns (bool ok) {
        vm.prank(attacker, attacker);
        (ok,) = address(router).call(
            abi.encodeCall(
                router.swap,
                (key, SwapParams(tokenIs0, -1, limit), PoolSwapTest.TestSettings(false, false), "")
            )
        );
    }

    function _honestBuy(uint256 imdIn) internal returns (BalanceDelta d) {
        vm.prank(address(this), honest);
        d = router.swap(
            key,
            SwapParams(!tokenIs0, -int256(imdIn), tokenIs0 ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function _checkHonestFee(BalanceDelta d) internal view {
        uint256 netOut = uint256(uint128(tokenIs0 ? d.amount0() : d.amount1()));
        uint256 fee = ERC20(token).balanceOf(treasury);
        (uint160 after_,,,) = IPoolManager(address(manager)).getSlot0(poolId);
        // All liquidity sits at the opening price; the honest swap's real impact is measured from there.
        uint256 realImpact = hook.priceImpactPips(SQRT_PRICE_1_1, after_);
        uint256 allowed = (netOut + fee) * hook.surchargePips(realImpact) / 1e6 + 1;
        assertLe(fee, allowed, "surcharge inflated by a zero-value price slide");
    }

    /// Outside the window: a free slide to the far limit makes the next buyer pay the 89.7% cap.
    function test_zeroValueSlideOutsideWindowInflatesNextSurcharge() public {
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
        uint256 attackerImdBefore = imd.balanceOf(attacker);
        bool slid = _slide(tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1);
        assertEq(imd.balanceOf(attacker), attackerImdBefore, "the slide cost the attacker nothing");
        if (slid) assertEq(ERC20(token).balanceOf(attacker), 0, "the attacker never held any token");

        BalanceDelta d = _honestBuy(1e22); // 0.001% of the pool: real impact ~0.002%
        _checkHonestFee(d);
    }

    /// Inside the window: a free 22% slide (under the breaker) either trips the breaker on the next honest buy
    /// or charges it the 89.7% cap, depending on which side the token sorts on.
    function test_zeroValueSlideInsideWindowBlocksOrOvertaxesNextBuy() public {
        // sqrt(0.78) and sqrt(1.22): a 22% price move toward the empty side.
        uint160 limit = tokenIs0
            ? uint160(uint256(SQRT_PRICE_1_1) * 883_176 / 1_000_000)
            : uint160(uint256(SQRT_PRICE_1_1) * 1_104_536 / 1_000_000);
        _slide(limit);

        BalanceDelta d = _honestBuy(1e22);
        _checkHonestFee(d);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

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

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

/// @notice Outside the opening window the surcharge is the only protection the brief leaves in place. The same
/// buyer, in the same transaction, moving the price by the same total amount must pay (about) the same surcharge
/// whether the move is one swap or two hundred.
contract SplitSwapTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant MAX_TICK = 887_220;
    int24 constant MIN_TICK = -887_220;

    PoolManager manager;
    PoolSwapTest router;
    PairMock imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address buyer = makeAddr("buyer");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new PairMock();
        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);
        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);

        address predicted = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextIs0 = predicted < address(imd);
        (int24 lower, int24 upper) = nextIs0 ? (int24(0), MAX_TICK) : (MIN_TICK, int24(0));
        (, token, key) = launchpad.launch("Fair", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;

        imd.mint(address(this), 1e30);
        imd.approve(address(router), type(uint256).max);
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS()); // window closed: no cooldown, no breaker
    }

    function _buy(uint256 imdIn) internal returns (BalanceDelta d) {
        vm.prank(address(this), buyer);
        d = router.swap(
            key,
            SwapParams(!tokenIs0, -int256(imdIn), tokenIs0 ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function _tok(BalanceDelta d) internal view returns (uint256) {
        return uint256(uint128(tokenIs0 ? d.amount0() : d.amount1()));
    }

    function test_splittingABuyInOneTransactionMustNotSlashTheSurcharge() public {
        uint256 total = 1e25; // moves the price ~2%: a single swap is at the 89.7% cap

        uint256 snap = vm.snapshotState();
        BalanceDelta one = _buy(total);
        uint256 outOne = _tok(one);
        uint256 feeOne = ERC20(token).balanceOf(treasury);
        (uint160 priceOne,,,) = IPoolManager(address(manager)).getSlot0(poolId);
        vm.revertToState(snap);

        uint256 n = 200;
        uint256 outMany;
        for (uint256 i = 0; i < n; i++) {
            outMany += _tok(_buy(total / n));
        }
        uint256 feeMany = ERC20(token).balanceOf(treasury);
        (uint160 priceMany,,,) = IPoolManager(address(manager)).getSlot0(poolId);

        // Same IMD in, same end price (within rounding): the price move is identical.
        assertApproxEqRel(uint256(priceMany), uint256(priceOne), 1e12, "same final price");
        assertGt(outMany, outOne, "the split buyer always receives at least as much");
        // The surcharge for the same move may not collapse. Today it is ~60x smaller (1.5% instead of 89.7%).
        assertGe(feeMany, feeOne / 2, "surcharge collapses when the buy is split into many swaps");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

contract ImdMock is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice A swap that fills nothing (the launchpad pool is single-sided, so one side has no liquidity) still moves
/// the pool price, and the hook settles that price as if a trade had happened. Anyone can therefore move the
/// settled price for free: inside the window this trips the circuit breaker for every real buy (launch DoS),
/// outside it the next buyer pays the maximum surcharge.
contract ZeroFillPushTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest router;
    ImdMock imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new ImdMock();

        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);
        assertEq(address(hook), predicted);

        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);
        imd.approve(address(router), type(uint256).max);

        // Launch exactly as the launchpad's own tests do: whole supply single-sided on the token side of 1:1.
        address nextToken = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextTokenIs0 = nextToken < address(imd);
        (int24 lower, int24 upper) = nextTokenIs0 ? (int24(0), int24(887_220)) : (int24(-887_220), int24(0));
        (, token, key) = launchpad.launch("Fair Coin", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;
        IERC20(token).approve(address(router), type(uint256).max);
    }

    function _sqrtPrice() internal view returns (uint160 p) {
        (p,,,) = IPoolManager(address(manager)).getSlot0(poolId);
    }

    function _tokenDelta(BalanceDelta d) internal view returns (int128) {
        return tokenIs0 ? d.amount0() : d.amount1();
    }

    /// @dev A "sell" of 1 wei of the launch token from `origin` with a price limit `bps` basis points of sqrt price
    /// away, into the side of the pool that holds no liquidity. Nothing is filled, nothing is paid; only the price
    /// moves. Failures are swallowed so that a fixed hook that refuses such swaps still passes the test.
    function _push(address origin, uint256 bps) internal {
        uint160 cur = _sqrtPrice();
        uint160 limit = tokenIs0 ? uint160(uint256(cur) * 10_000 / bps) : uint160(uint256(cur) * bps / 10_000);
        if (limit <= TickMath.MIN_SQRT_PRICE) limit = TickMath.MIN_SQRT_PRICE + 1;
        if (limit >= TickMath.MAX_SQRT_PRICE) limit = TickMath.MAX_SQRT_PRICE - 1;
        vm.prank(address(this), origin);
        try router.swap(
            key,
            SwapParams({zeroForOne: tokenIs0, amountSpecified: -1, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        ) {} catch {}
    }

    function _buy(address origin, int256 amountSpecified) internal returns (BalanceDelta) {
        vm.prank(address(this), origin);
        return router.swap(
            key,
            SwapParams({
                zeroForOne: !tokenIs0,
                amountSpecified: amountSpecified,
                sqrtPriceLimitX96: !tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    /// @notice Inside the window: two attacker wallets each move the price 24% (under the 25% breaker) for free.
    /// Alice's ordinary buy of 0.1% of the supply must still go through; on the current hook it reverts with
    /// CircuitBreaker because the settled price is now 1.54x away from the liquidity.
    function test_buyInsideWindowSurvivesZeroFillPushes() public {
        uint256 attackerTokensBefore = IERC20(token).balanceOf(address(this));
        _push(address(0xA1), 11_135); // sqrt ratio 1.1135 -> price ratio 1.24
        _push(address(0xA2), 11_135);
        assertEq(IERC20(token).balanceOf(address(this)), attackerTokensBefore, "the pushes cost the attacker nothing");

        BalanceDelta d = _buy(alice, int256(1e24));
        assertEq(uint256(uint128(_tokenDelta(d))), 1e24, "alice bought 0.1% of the supply inside the window");
    }

    /// @notice Outside the window: one free push far into the empty side. Alice's exact-input buy of 1e24 IMD then
    /// measures a huge "impact" and loses the maximum surcharge (89.7% of her tokens) to the treasury, although
    /// her trade moved the pool price from the liquidity edge by far less than that.
    function test_buyOutsideWindowIsNotSurchargedForAFreePush() public {
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
        _push(address(0xA1), 30_000); // sqrt ratio 3 -> price ratio 9, no breaker outside the window

        BalanceDelta d = _buy(alice, -int256(1e24));
        uint256 net = uint256(uint128(_tokenDelta(d)));
        uint256 fee = IERC20(token).balanceOf(treasury);
        assertLt(fee * 10, net + fee, "the surcharge on an ordinary buy is far below 10% of the output");
    }
}

// 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 {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.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} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {HookMiner} from "src/HookMiner.sol";

contract ProofToken is ERC20 {
    constructor() ERC20("T", "T") {}

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

/// The circuit breaker measures the move of the pool's raw price (currency1 per currency0), not of the launch
/// token's price in IMD. When the launch token sorts as currency1 its IMD price is the inverse of the raw price,
/// so a buy that raises the token's price by 31.6% shows up as a 24% raw move and passes the 25% breaker. The
/// same buy against a token that sorts as currency0 reverts.
contract ProofBreakerSide is Test {
    uint160 constant SQRT_1_1 = 79228162514264337593543950336;
    uint160 constant SQRT_0_76 = 69069510776419123089131622757; // raw price 0.76 -> token (currency1) +31.6%
    uint160 constant SQRT_1_316 = 90880935232130430746647892800; // raw price 1/0.76 -> token (currency0) +31.6%
    uint256 constant LIQ = 1e24;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    SigmoidIMD hook;

    function _setUp(bool tokenIs0) internal returns (PoolKey memory key) {
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        ProofToken token = new ProofToken();
        // Place IMD above or below the token so the token lands on the wanted side.
        address imdAt = tokenIs0 ? address(uint160(type(uint160).max - 0xffff)) : address(uint160(0x10000));
        vm.etch(imdAt, address(new ProofToken()).code);
        ProofToken imd = ProofToken(imdAt);

        bytes memory args = abi.encode(IPoolManager(address(manager)), imdAt, address(0xBEEF));
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), imdAt, address(0xBEEF));

        token.mint(address(this), 1e27);
        imd.mint(address(this), 1e30);
        token.approve(address(swapRouter), type(uint256).max);
        token.approve(address(lpRouter), type(uint256).max);
        imd.approve(address(swapRouter), type(uint256).max);
        imd.approve(address(lpRouter), type(uint256).max);

        (address c0, address c1) = tokenIs0 ? (address(token), imdAt) : (imdAt, address(token));
        key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, SQRT_1_1);
        lpRouter.modifyLiquidity(
            key,
            ModifyLiquidityParams(TickMath.minUsableTick(60), TickMath.maxUsableTick(60), int256(LIQ), 0),
            ""
        );
        assertEq(Currency.unwrap(tokenIs0 ? key.currency0 : key.currency1), address(token));
    }

    /// Buy (IMD in, token out) that stops exactly where the token's IMD price is 31.6% above the opening.
    function _buyPast25Percent(PoolKey memory key, bool tokenIs0) internal {
        swapRouter.swap(
            key,
            SwapParams({
                zeroForOne: !tokenIs0,
                amountSpecified: -int256(1e24),
                sqrtPriceLimitX96: tokenIs0 ? SQRT_1_316 : SQRT_0_76
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    /// Control: token as currency0, the +31.6% buy trips the breaker (passes on the current code).
    function test_tokenAsCurrency0_buyMovingTokenPrice31PercentReverts() public {
        PoolKey memory key = _setUp(true);
        vm.expectRevert();
        _buyPast25Percent(key, true);
    }

    /// Defect: token as currency1, the economically identical +31.6% buy goes through (fails on the current code).
    function test_tokenAsCurrency1_buyMovingTokenPrice31PercentReverts() public {
        PoolKey memory key = _setUp(false);
        vm.expectRevert();
        _buyPast25Percent(key, false);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

contract ImdMock is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice The surcharge is `s x |unspecified amount|`. On an exact-output swap the unspecified amount is the
/// input and the fee is added on top of it, so the treasury's share of what the trader hands over is s/(1+s):
/// 47.3% at the 89.7% cap instead of 89.7%. The same price move quoted as exact input pays 89.7% of its output.
contract ProofExactOutputShare is Test {
    using PoolIdLibrary for PoolKey;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest router;
    ImdMock imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new ImdMock();

        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);

        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);
        imd.approve(address(router), type(uint256).max);

        address nextToken = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextTokenIs0 = nextToken < address(imd);
        (int24 lower, int24 upper) = nextTokenIs0 ? (int24(0), int24(887_220)) : (int24(-887_220), int24(0));
        (, token, key) = launchpad.launch("Fair Coin", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;
        IERC20(token).approve(address(router), type(uint256).max);

        // Outside the window: only the dynamic fee remains.
        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
    }

    function _buy(int256 amountSpecified) internal returns (BalanceDelta) {
        vm.prank(address(this), alice);
        return router.swap(
            key,
            SwapParams({
                zeroForOne: !tokenIs0,
                amountSpecified: amountSpecified,
                sqrtPriceLimitX96: !tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function _imdDelta(BalanceDelta d) internal view returns (int128) {
        return tokenIs0 ? d.amount1() : d.amount0();
    }

    /// @notice An exact-output buy of 1% of the supply has an impact far past the point where the surcharge
    /// is capped at 897,000 pips. The treasury's share of the IMD the trader pays must be that rate, as it is on
    /// an exact-input swap. On the current code it is 472,851 pips.
    function test_exactOutputBuyPaysTheStatedShareOfWhatTheTraderPays() public {
        BalanceDelta d = _buy(int256(1e25));
        uint256 gross = uint256(uint128(-_imdDelta(d)));
        // Fresh manager holds no IMD before this swap, so the surcharge is kept as a claim.
        uint256 fee = imd.balanceOf(treasury) + hook.pendingFees(Currency.wrap(address(imd)));
        assertGt(fee, 0, "a surcharge was charged");
        uint256 cap = uint256(hook.MAX_TOTAL_FEE()) - uint256(hook.BASE_LP_FEE());
        uint256 share = fee * 1e6 / gross;
        assertGe(share, cap - 10_000, "exact output must pay the same share of what the trader pays as exact input");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {SigmoidIMD} from "src/SigmoidIMD.sol";
import {SigmoidLaunchpad} from "src/SigmoidLaunchpad.sol";
import {HookMiner} from "src/HookMiner.sol";

contract ImdMock is ERC20 {
    constructor() ERC20("IMD", "IMD") {
        _mint(msg.sender, 1e30);
    }
}

/// @notice The surcharge is 150 x the impact of each swap measured from the price settled by the previous swap,
/// and afterSwap re-settles after every swap. Outside the window nothing bounds the number of swaps one
/// transaction may make, so a buy split into N pieces pays about 1/N of the surcharge of the single swap that
/// produces the same price move.
contract ProofSplitSwaps is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    PoolSwapTest router;
    ImdMock imd;
    SigmoidIMD hook;
    SigmoidLaunchpad launchpad;
    address treasury = makeAddr("treasury");
    address alice = makeAddr("alice");

    PoolKey key;
    PoolId poolId;
    address token;
    bool tokenIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new PoolSwapTest(manager);
        imd = new ImdMock();

        bytes memory args = abi.encode(IPoolManager(address(manager)), address(imd), treasury);
        (, bytes32 salt) =
            HookMiner.find(address(this), HookMiner.SIGMOID_FLAGS, type(SigmoidIMD).creationCode, args, 500_000);
        hook = new SigmoidIMD{salt: salt}(IPoolManager(address(manager)), address(imd), treasury);

        launchpad = new SigmoidLaunchpad(IPoolManager(address(manager)), hook);
        imd.approve(address(router), type(uint256).max);

        address nextToken = vm.computeCreateAddress(address(launchpad), vm.getNonce(address(launchpad)));
        bool nextTokenIs0 = nextToken < address(imd);
        (int24 lower, int24 upper) = nextTokenIs0 ? (int24(0), int24(887_220)) : (int24(-887_220), int24(0));
        (, token, key) = launchpad.launch("Fair Coin", "FAIR", SQRT_PRICE_1_1, lower, upper);
        poolId = key.toId();
        tokenIs0 = Currency.unwrap(key.currency0) == token;
        IERC20(token).approve(address(router), type(uint256).max);

        vm.roll(block.number + hook.OPENING_WINDOW_BLOCKS());
    }

    function _buyExactIn(uint256 imdIn) internal returns (BalanceDelta) {
        vm.prank(address(this), alice);
        return router.swap(
            key,
            SwapParams({
                zeroForOne: !tokenIs0,
                amountSpecified: -int256(imdIn),
                sqrtPriceLimitX96: !tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            }),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function _sqrtPrice() internal view returns (uint160 p) {
        (p,,,) = IPoolManager(address(manager)).getSlot0(poolId);
    }

    /// @notice One 1e25 IMD buy versus 200 buys of 5e22 IMD from the same origin in one transaction, from the
    /// same pool state. Both end at the same price. The split trade must not pay less than half the surcharge.
    function test_splittingABuyDoesNotCutTheSurcharge() public {
        uint256 snap = vm.snapshotState();

        _buyExactIn(1e25);
        uint256 feeOne = IERC20(token).balanceOf(treasury);
        uint160 priceOne = _sqrtPrice();

        vm.revertToState(snap);

        for (uint256 i = 0; i < 200; i++) {
            _buyExactIn(5e22);
        }
        uint256 feeMany = IERC20(token).balanceOf(treasury);
        uint160 priceMany = _sqrtPrice();

        assertApproxEqRel(uint256(priceMany), uint256(priceOne), 1e15, "both shapes end at the same price");
        assertGe(feeMany, feeOne / 2, "splitting the trade must not cut the surcharge");
    }
}