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

import {Test} from "forge-std/Test.sol";
import {SigmaHook} from "src/SigmaHook.sol";
import {SigmaToken} from "src/SigmaToken.sol";
import {HookFlags} from "src/HookFlags.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {
        _mint(msg.sender, 10_000_000 ether);
    }
}

contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amount, uint160 limit) external {
        manager.unlock(abi.encode(uint8(0), key, abi.encode(SwapParams(zeroForOne, amount, limit))));
    }

    function modify(PoolKey memory key, int24 lower, int24 upper, int256 change) external {
        manager.unlock(abi.encode(uint8(1), key, abi.encode(ModifyLiquidityParams(lower, upper, change, bytes32(0)))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (uint8 action, PoolKey memory key, bytes memory args) = abi.decode(data, (uint8, PoolKey, bytes));
        BalanceDelta delta;
        if (action == 0) delta = manager.swap(key, abi.decode(args, (SwapParams)), "");
        else (delta,) = manager.modifyLiquidity(key, abi.decode(args, (ModifyLiquidityParams)), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

    function _settle(Currency c, int128 d) private {
        if (d > 0) {
            manager.take(c, address(this), uint128(d));
        } else if (d < 0) {
            manager.sync(c);
            c.transfer(address(manager), uint256(-int256(d)));
            manager.settle();
        }
    }
}

contract IdleAfterRebalanceTest is Test {
    using StateLibrary for IPoolManager;

    IPoolManager manager;
    SigmaHook hook;
    SigmaToken token;
    PairToken weth;
    Router router;
    PoolKey key;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new SigmaToken();
        weth = new PairToken();
        bytes memory initCode = bytes.concat(
            type(SigmaHook).creationCode, abi.encode(manager, makeAddr("owner"), address(token), address(this))
        );
        bytes32 hash = keccak256(initCode);
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SIGMA)) continue;
            hook = new SigmaHook{salt: bytes32(i)}(manager, makeAddr("owner"), address(token), address(this));
            break;
        }
        (address a, address b) =
            address(token) < address(weth) ? (address(token), address(weth)) : (address(weth), address(token));
        key = PoolKey(Currency.wrap(a), Currency.wrap(b), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96);
        router = new Router(manager);
        token.transfer(address(router), 1_000_000 ether);
        weth.transfer(address(router), 1_000_000 ether);
        router.modify(key, -887220, 887220, 1_000 ether); // background full-range LP
        token.transfer(alice, 10_000 ether);
        weth.transfer(alice, 10_000 ether);
        vm.startPrank(alice);
        token.approve(address(hook), type(uint256).max);
        weth.approve(address(hook), type(uint256).max);
        hook.deposit(1_000 ether, 1_000 ether, 1, alice, block.timestamp);
        vm.stopPrank();
    }

    function _moveTo(int24 target) internal {
        (uint160 current,,,) = manager.getSlot0(key.toId());
        uint160 limit = TickMath.getSqrtPriceAtTick(target);
        router.swap(key, limit < current, -int256(100_000 ether), limit);
    }

    /// Once price leaves the band, the vault is one-sided; every later band contains the spot
    /// tick, so _invest needs both tokens, mints 0 liquidity, and the vault never earns fees again.
    function test_vaultStaysIdleForeverAfterTrendRebalance() public {
        assertGt(hook.liquidity(), 0);
        uint256 t = block.timestamp + 31 minutes;
        vm.warp(t);
        _moveTo(2000); // price trends out of [-60,60]; afterSwap rebalances
        assertEq(hook.lastRebalance(), t, "rebalance fired");
        assertEq(hook.liquidity(), 0, "redeployed nothing");

        // Further rebalance windows, with price returning and moving again.
        for (uint256 i; i < 4; ++i) {
            for (uint256 j; j < 8; ++j) {
                router.swap(key, true, -1000, TickMath.MIN_SQRT_PRICE + 1); // fill the feed at this level
            }
            t += 31 minutes;
            vm.warp(t);
            _moveTo(i % 2 == 0 ? int24(-1500) : int24(1500));
            assertEq(hook.lastRebalance(), t, "later rebalance fired");
        }
        emit log_named_uint("lastRebalance", hook.lastRebalance());
        emit log_named_uint("liquidity", hook.liquidity());
        assertGt(hook.liquidity(), 0, "vault capital never redeployed after a trend rebalance");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SigmaHook} from "src/SigmaHook.sol";
import {SigmaToken} from "src/SigmaToken.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {
        _mint(msg.sender, 1_000_000 ether);
    }
}

contract FirstDepositTest is Test {
    IPoolManager manager;
    SigmaHook hook;
    SigmaToken token;
    PairToken weth;
    PoolKey key;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new SigmaToken();
        weth = new PairToken();
        bytes memory initCode = bytes.concat(
            type(SigmaHook).creationCode, abi.encode(manager, makeAddr("owner"), address(token), address(this))
        );
        bytes32 hash = keccak256(initCode);
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SIGMA)) continue;
            hook = new SigmaHook{salt: bytes32(i)}(manager, makeAddr("owner"), address(token), address(this));
            break;
        }
        (address a, address b) =
            address(token) < address(weth) ? (address(token), address(weth)) : (address(weth), address(token));
        key = PoolKey(Currency.wrap(a), Currency.wrap(b), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96); // tick 0, vault band [-60, 60]
        token.transfer(alice, 10 ether);
        weth.transfer(alice, 10 ether);
        vm.startPrank(alice);
        token.approve(address(hook), type(uint256).max);
        weth.approve(address(hook), type(uint256).max);
        vm.stopPrank();
    }

    function _wealth() internal view returns (uint256) {
        return token.balanceOf(alice) + weth.balanceOf(alice);
    }

    /// First deposit with an unbalanced budget: the whole budget is pulled although liquidity
    /// uses ~10 wei of it, and the 1_000 dead shares capture ~30% of the surplus.
    function test_firstDepositPullsUnusedBudgetIntoDeadShares() public {
        uint256 start = _wealth();
        vm.prank(alice);
        (uint256 shares, uint256 amount0, uint256 amount1) = hook.deposit(1 ether, 10, 1, alice, block.timestamp);
        emit log_named_uint("shares", shares);
        emit log_named_uint("pulled0", amount0);
        emit log_named_uint("pulled1", amount1);
        vm.prank(alice);
        hook.withdraw(shares, 0, 0, alice, block.timestamp);
        uint256 lost = start - _wealth();
        emit log_named_uint("lost", lost);
        // A sole depositor exiting immediately should lose dust at most.
        assertLe(lost, 1e12, "first depositor's unused budget is locked behind MINIMUM_SHARES");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {VaultMath} from "src/libraries/VaultMath.sol";
import {SigmaHook} from "src/SigmaHook.sol";
import {SigmaToken} from "src/SigmaToken.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {WETH} from "solmate/src/tokens/WETH.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {SqrtPriceMath} from "v4-core/src/libraries/SqrtPriceMath.sol";

contract LiquiditySizingProofTest is Test {
    function test_depositLeavesAlmostHalfOfInvestablePrincipalIdle() public {
        IPoolManager manager = IPoolManager(address(new PoolManager(address(this))));
        SigmaToken token = new SigmaToken();
        WETH weth = new WETH();
        vm.deal(address(this), 1_000 ether);
        weth.deposit{value: 1_000 ether}();
        SigmaHook hook;
        bytes32 initHash = keccak256(abi.encodePacked(
            type(SigmaHook).creationCode, abi.encode(manager, address(this), address(token), address(this))
        ));
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(uint160(uint256(keccak256(
                abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)
            ))));
            if (!HookFlags.matches(predicted, HookFlags.SIGMA)) continue;
            hook = new SigmaHook{salt: bytes32(i)}(manager, address(this), address(token), address(this));
            break;
        }
        require(address(hook) != address(0), "CREATE2 search exhausted");
        (address a, address b) = address(token) < address(weth)
            ? (address(token), address(weth)) : (address(weth), address(token));
        PoolKey memory key = PoolKey(Currency.wrap(a), Currency.wrap(b), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(-658620));
        token.approve(address(hook), type(uint256).max);
        weth.approve(address(hook), type(uint256).max);
        hook.deposit(1_000 ether, 1, 1, address(this), block.timestamp);
        assertGt(hook.liquidity(), 0);
        emit log_named_uint("liquidity", hook.liquidity());
        emit log_named_uint("idle currency0", key.currency0.balanceOf(address(hook)));
        // The current price is inside the bands, no other LP consumes capacity, and both
        // budgets can support deploying over 90% of currency0 (see independent cost oracle).
        assertLe(key.currency0.balanceOf(address(hook)), 100 ether, "material principal left idle, not rounding dust");
    }

    function test_lowTickSizingLeavesMaterialInvestableCapitalIdle() public pure {
        uint160 price = TickMath.getSqrtPriceAtTick(-658620);
        uint160 lower = TickMath.getSqrtPriceAtTick(-658680);
        uint160 upper = TickMath.getSqrtPriceAtTick(-658560);
        uint256 budget0 = 1_000 ether;
        uint256 budget1 = 1;
        uint128 capacity = 1e30;
        uint128 actual = VaultMath.liquidityForAmounts(price, lower, upper, budget0, budget1, capacity);

        // Binary search the manager's round-up token costs, independently of the sizing formula.
        uint128 lo;
        uint128 hi = capacity;
        while (lo < hi) {
            uint128 mid = lo + (hi - lo + 1) / 2;
            if (SqrtPriceMath.getAmount0Delta(price, upper, mid, true) <= budget0
                && SqrtPriceMath.getAmount1Delta(lower, price, mid, true) <= budget1) lo = mid;
            else hi = mid - 1;
        }
        uint128 affordable = lo * 9 / 10;
        assertLe(SqrtPriceMath.getAmount0Delta(price, upper, affordable, true), budget0);
        assertLe(SqrtPriceMath.getAmount1Delta(lower, price, affordable, true), budget1);
        assertLt(affordable, capacity);
        assertGe(actual, affordable, "more than 10% of investable liquidity left idle");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SigmaHook} from "src/SigmaHook.sol";
import {SigmaToken} from "src/SigmaToken.sol";
import {HookFlags} from "src/HookFlags.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {
        _mint(msg.sender, 10_000_000 ether);
    }
}

contract Router is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amount, uint160 limit) external {
        manager.unlock(abi.encode(uint8(0), key, abi.encode(SwapParams(zeroForOne, amount, limit))));
    }

    function modify(PoolKey memory key, int24 lower, int24 upper, int256 change) external {
        manager.unlock(abi.encode(uint8(1), key, abi.encode(ModifyLiquidityParams(lower, upper, change, bytes32(0)))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (uint8 action, PoolKey memory key, bytes memory args) = abi.decode(data, (uint8, PoolKey, bytes));
        BalanceDelta delta;
        if (action == 0) delta = manager.swap(key, abi.decode(args, (SwapParams)), "");
        else (delta,) = manager.modifyLiquidity(key, abi.decode(args, (ModifyLiquidityParams)), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return "";
    }

    function _settle(Currency c, int128 d) private {
        if (d > 0) {
            manager.take(c, address(this), uint128(d));
        } else if (d < 0) {
            manager.sync(c);
            c.transfer(address(manager), uint256(-int256(d)));
            manager.settle();
        }
    }
}

contract IdleAfterRebalanceTest is Test {
    using StateLibrary for IPoolManager;

    IPoolManager manager;
    SigmaHook hook;
    SigmaToken token;
    PairToken weth;
    Router router;
    PoolKey key;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new SigmaToken();
        weth = new PairToken();
        bytes memory initCode = bytes.concat(
            type(SigmaHook).creationCode, abi.encode(manager, makeAddr("owner"), address(token), address(this))
        );
        bytes32 hash = keccak256(initCode);
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SIGMA)) continue;
            hook = new SigmaHook{salt: bytes32(i)}(manager, makeAddr("owner"), address(token), address(this));
            break;
        }
        (address a, address b) =
            address(token) < address(weth) ? (address(token), address(weth)) : (address(weth), address(token));
        key = PoolKey(Currency.wrap(a), Currency.wrap(b), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96);
        router = new Router(manager);
        token.transfer(address(router), 1_000_000 ether);
        weth.transfer(address(router), 1_000_000 ether);
        router.modify(key, -887220, 887220, 1_000 ether); // background full-range LP
        token.transfer(alice, 10_000 ether);
        weth.transfer(alice, 10_000 ether);
        vm.startPrank(alice);
        token.approve(address(hook), type(uint256).max);
        weth.approve(address(hook), type(uint256).max);
        hook.deposit(1_000 ether, 1_000 ether, 1, alice, block.timestamp);
        vm.stopPrank();
    }

    function _moveTo(int24 target) internal {
        (uint160 current,,,) = manager.getSlot0(key.toId());
        uint160 limit = TickMath.getSqrtPriceAtTick(target);
        router.swap(key, limit < current, -int256(100_000 ether), limit);
    }

    /// Once price leaves the band, the vault is one-sided; every later band contains the spot
    /// tick, so _invest needs both tokens, mints 0 liquidity, and the vault never earns fees again.
    function test_vaultStaysIdleForeverAfterTrendRebalance() public {
        assertGt(hook.liquidity(), 0);
        uint256 t = block.timestamp + 31 minutes;
        vm.warp(t);
        _moveTo(2000); // price trends out of [-60,60]; afterSwap rebalances
        assertEq(hook.lastRebalance(), t, "rebalance fired");
        assertEq(hook.liquidity(), 0, "redeployed nothing");

        // Further rebalance windows, with price returning and moving again.
        for (uint256 i; i < 4; ++i) {
            for (uint256 j; j < 8; ++j) {
                router.swap(key, true, -1000, TickMath.MIN_SQRT_PRICE + 1); // fill the feed at this level
            }
            t += 31 minutes;
            vm.warp(t);
            _moveTo(i % 2 == 0 ? int24(-1500) : int24(1500));
            assertEq(hook.lastRebalance(), t, "later rebalance fired");
        }
        emit log_named_uint("lastRebalance", hook.lastRebalance());
        emit log_named_uint("liquidity", hook.liquidity());
        assertGt(hook.liquidity(), 0, "vault capital never redeployed after a trend rebalance");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SigmaHook} from "src/SigmaHook.sol";
import {SigmaToken} from "src/SigmaToken.sol";
import {HookFlags} from "src/HookFlags.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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract PairToken is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {
        _mint(msg.sender, 1_000_000 ether);
    }
}

contract FirstDepositTest is Test {
    IPoolManager manager;
    SigmaHook hook;
    SigmaToken token;
    PairToken weth;
    PoolKey key;
    address alice = makeAddr("alice");

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new SigmaToken();
        weth = new PairToken();
        bytes memory initCode = bytes.concat(
            type(SigmaHook).creationCode, abi.encode(manager, makeAddr("owner"), address(token), address(this))
        );
        bytes32 hash = keccak256(initCode);
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SIGMA)) continue;
            hook = new SigmaHook{salt: bytes32(i)}(manager, makeAddr("owner"), address(token), address(this));
            break;
        }
        (address a, address b) =
            address(token) < address(weth) ? (address(token), address(weth)) : (address(weth), address(token));
        key = PoolKey(Currency.wrap(a), Currency.wrap(b), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96); // tick 0, vault band [-60, 60]
        token.transfer(alice, 10 ether);
        weth.transfer(alice, 10 ether);
        vm.startPrank(alice);
        token.approve(address(hook), type(uint256).max);
        weth.approve(address(hook), type(uint256).max);
        vm.stopPrank();
    }

    function _wealth() internal view returns (uint256) {
        return token.balanceOf(alice) + weth.balanceOf(alice);
    }

    /// First deposit with an unbalanced budget: the whole budget is pulled although liquidity
    /// uses ~10 wei of it, and the 1_000 dead shares capture ~30% of the surplus.
    function test_firstDepositPullsUnusedBudgetIntoDeadShares() public {
        uint256 start = _wealth();
        vm.prank(alice);
        (uint256 shares, uint256 amount0, uint256 amount1) = hook.deposit(1 ether, 10, 1, alice, block.timestamp);
        emit log_named_uint("shares", shares);
        emit log_named_uint("pulled0", amount0);
        emit log_named_uint("pulled1", amount1);
        vm.prank(alice);
        hook.withdraw(shares, 0, 0, alice, block.timestamp);
        uint256 lost = start - _wealth();
        emit log_named_uint("lost", lost);
        // A sole depositor exiting immediately should lose dust at most.
        assertLe(lost, 1e12, "first depositor's unused budget is locked behind MINIMUM_SHARES");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SigmaHook} from "src/SigmaHook.sol";
import {SigmaToken} from "src/SigmaToken.sol";
import {HookFlags} from "src/HookFlags.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.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";

contract ProofWeth is ERC20 {
    constructor() ERC20("Wrapped Ether", "WETH") {
        _mint(msg.sender, 1_000_000 ether);
    }
}

/// @dev Swaps against an empty pool only, so it never owes or receives tokens.
contract EmptyPoolMover is IUnlockCallback {
    IPoolManager private immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function move(PoolKey memory key, bool zeroForOne, uint160 limit) external {
        manager.unlock(abi.encode(key, SwapParams(zeroForOne, -1 ether, limit)));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, SwapParams memory params) = abi.decode(data, (PoolKey, SwapParams));
        BalanceDelta delta = manager.swap(key, params, "");
        require(BalanceDelta.unwrap(delta) == 0, "empty pool moved tokens");
        return "";
    }
}

contract PreviewDepositStaleBandProof is Test {
    IPoolManager private manager;
    SigmaHook private hook;
    PoolKey private key;
    address private alice = makeAddr("alice");

    function setUp() public {
        address owner = makeAddr("owner");
        manager = IPoolManager(address(new PoolManager(owner)));
        SigmaToken token = new SigmaToken();
        ProofWeth weth = new ProofWeth();
        bytes memory initCode =
            bytes.concat(type(SigmaHook).creationCode, abi.encode(manager, owner, address(token), address(this)));
        bytes32 hash = keccak256(initCode);
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SIGMA) || predicted.code.length != 0) continue;
            hook = new SigmaHook{salt: bytes32(i)}(manager, owner, address(token), address(this));
            break;
        }
        require(address(hook) != address(0), "salt search exhausted");
        (address a, address b) =
            address(token) < address(weth) ? (address(token), address(weth)) : (address(weth), address(token));
        key = PoolKey(Currency.wrap(a), Currency.wrap(b), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96);
        token.transfer(alice, 100 ether);
        weth.transfer(alice, 100 ether);
        vm.startPrank(alice);
        token.approve(address(hook), type(uint256).max);
        weth.approve(address(hook), type(uint256).max);
        vm.stopPrank();
    }

    /// The pool is created at tick 0 with band [-60, 60]. Before anyone deposits, a swap on the empty
    /// pool moves the price to tick 60 and records it in the feed. previewDeposit(0, 10 ether) quotes the
    /// stored band [-60, 60], where tick 60 is the upper edge and a currency1-only basket buys shares.
    /// deposit() first refreshes the band from the feed to one that contains tick 60, so the same
    /// basket buys nothing and the deposit reverts with Slippage() for the quoted minShares.
    function test_firstDepositMatchesItsPreviewAfterTheFeedMoved() public {
        new EmptyPoolMover(manager).move(key, false, TickMath.getSqrtPriceAtTick(60));
        assertEq(hook.liquidity(), 0);
        (uint256 quote, uint256 quoted0, uint256 quoted1) = hook.previewDeposit(0, 10 ether);
        assertGt(quote, 0, "preview offers shares for the basket");
        vm.prank(alice);
        (uint256 shares, uint256 paid0, uint256 paid1) = hook.deposit(0, 10 ether, quote, alice, block.timestamp);
        assertEq(shares, quote, "deposit must honour its spot-state preview");
        assertEq(paid0, quoted0);
        assertEq(paid1, quoted1);
    }
}