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

import {Test} from "forge-std/Test.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {BeforeSwapDelta, toBeforeSwapDelta} from "v4-core/src/types/BeforeSwapDelta.sol";

contract ProofImdCap is ERC20 {
    constructor() ERC20("Local IMD", "IMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

abstract contract ProofFixtureCap is Test, IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address constant ORDERS = 0x721F8232e19c92516eB753FEF53d8A33a3637989;
    address constant DEV = 0xb59eac9882Ba98f4170d99D5F402C3EDb6D50D75;
    uint160 constant Q96 = 79228162514264337593543950336;
    Paper paper;
    PaperHook hook;
    PaperHook logic;
    PoolManager manager;
    PoolKey key;

    function setUp() public {
        paper = new Paper();
        ProofImdCap template = new ProofImdCap();
        vm.etch(IMD, address(template).code);
        ProofImdCap(IMD).mint(address(this), 1e30);
        manager = new PoolManager(address(this));
        logic = new PaperHook(manager);
        PaperDeployment deployment = new PaperDeployment();
        PaperDeployment.Config memory config = PaperDeployment.Config(
            manager, address(paper), address(this), 1 ether, Q96, 3000, 60
        );
        bytes32 codeHash = keccak256(deployment.proxyInitCode(address(logic), config));
        (bytes32 salt,) = deployment.mine(address(deployment), codeHash, 0, 200_000);
        hook = deployment.deployHook(salt, address(logic), config);
        key = hook.poolKey();
    }

    function seed(int24 lower, int24 upper) internal {
        manager.unlock(abi.encode(false, lower, upper));
    }

    function buy() internal {
        manager.unlock(abi.encode(true, int24(0), int24(0)));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool swap, int24 lower, int24 upper) = abi.decode(data, (bool, int24, int24));
        BalanceDelta delta;
        if (swap) {
            bool zeroForOne = Currency.unwrap(key.currency0) == IMD;
            uint160 limit = zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341;
            delta = manager.swap(key, SwapParams(zeroForOne, -100 ether, limit), "");
        } else {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, 1e24, 0), "");
        }
        settle(key.currency0, delta.amount0());
        settle(key.currency1, delta.amount1());
        return "";
    }

    function settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            manager.sync(currency);
            require(IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(delta))));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, address(this), uint256(int256(delta)));
        }
    }
}

// Test-only replacement. Its fallback preserves existing application state/getters.
// Only the IMD exact-input buy callback changes, from 2% to 10%.
contract TenPercentReplacement {
    address private immutable original;
    IPoolManager private immutable manager;
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address constant ORDERS = 0x721F8232e19c92516eB753FEF53d8A33a3637989;
    address constant DEV = 0xb59eac9882Ba98f4170d99D5F402C3EDb6D50D75;
    constructor(address original_, IPoolManager manager_) { original = original_; manager = manager_; }
    function beforeSwap(address, PoolKey calldata key, SwapParams calldata p, bytes calldata)
        external returns (bytes4, BeforeSwapDelta, uint24)
    {
        require(msg.sender == address(manager));
        require(p.amountSpecified < 0 && p.zeroForOne == (Currency.unwrap(key.currency0) == IMD));
        uint256 fee = uint256(-p.amountSpecified) / 10;
        manager.take(Currency.wrap(IMD), ORDERS, fee / 4);
        manager.take(Currency.wrap(IMD), DEV, fee - fee / 4);
        return (IHooks.beforeSwap.selector, toBeforeSwapDelta(int128(int256(fee)), 0), 0);
    }
    function afterSwap(address, PoolKey calldata, SwapParams calldata, BalanceDelta, bytes calldata)
        external view returns (bytes4, int128)
    {
        require(msg.sender == address(manager));
        return (IHooks.afterSwap.selector, 0);
    }
    fallback() external {
        address target = original;
        assembly {
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas(), target, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if iszero(success) { revert(0, returndatasize()) }
            return(0, returndatasize())
        }
    }
}

contract ImmutableFeeProof is ProofFixtureCap {
    function test_upgradeCannotRaiseTheTwoPercentFee() public {
        seed(-887220, 887220);
        TenPercentReplacement replacement = new TenPercentReplacement(address(logic), manager);
        bytes32 adminSlot = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
        ProxyAdmin admin = ProxyAdmin(address(uint160(uint256(vm.load(address(hook), adminSlot)))));
        assertEq(admin.owner(), DEV);
        vm.prank(DEV);
        // A fix may reject an incompatible replacement; otherwise the cap must still hold.
        (bool upgraded,) = address(admin).call(abi.encodeCall(
            ProxyAdmin.upgradeAndCall, (ITransparentUpgradeableProxy(address(hook)), address(replacement), bytes(""))
        ));
        upgraded;
        uint256 paperBefore = paper.balanceOf(address(this));
        buy();
        assertGt(paper.balanceOf(address(this)), paperBefore, "a real swap must execute");
        uint256 paid = IERC20(IMD).balanceOf(ORDERS) + IERC20(IMD).balanceOf(DEV);
        assertEq(paid, 2 ether, "100 IMD buy must never pay more than the constant 2% fee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ProxyAdmin} from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
import {ITransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {BeforeSwapDelta, toBeforeSwapDelta} from "v4-core/src/types/BeforeSwapDelta.sol";

contract ProofImdFirstBuy is ERC20 {
    constructor() ERC20("Local IMD", "IMD") {}
    function mint(address to, uint256 amount) external { _mint(to, amount); }
}

abstract contract ProofFixtureFirstBuy is Test, IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address constant ORDERS = 0x721F8232e19c92516eB753FEF53d8A33a3637989;
    address constant DEV = 0xb59eac9882Ba98f4170d99D5F402C3EDb6D50D75;
    uint160 constant Q96 = 79228162514264337593543950336;
    Paper paper;
    PaperHook hook;
    PaperHook logic;
    PoolManager manager;
    PoolKey key;

    function setUp() public {
        paper = new Paper();
        ProofImdFirstBuy template = new ProofImdFirstBuy();
        vm.etch(IMD, address(template).code);
        ProofImdFirstBuy(IMD).mint(address(this), 1e30);
        manager = new PoolManager(address(this));
        logic = new PaperHook(manager);
        PaperDeployment deployment = new PaperDeployment();
        PaperDeployment.Config memory config = PaperDeployment.Config(
            manager, address(paper), address(this), 1 ether, Q96, 3000, 60
        );
        bytes32 codeHash = keccak256(deployment.proxyInitCode(address(logic), config));
        (bytes32 salt,) = deployment.mine(address(deployment), codeHash, 0, 200_000);
        hook = deployment.deployHook(salt, address(logic), config);
        key = hook.poolKey();
    }

    function seed(int24 lower, int24 upper) internal {
        manager.unlock(abi.encode(false, lower, upper));
    }

    function buy() internal {
        manager.unlock(abi.encode(true, int24(0), int24(0)));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool swap, int24 lower, int24 upper) = abi.decode(data, (bool, int24, int24));
        BalanceDelta delta;
        if (swap) {
            bool zeroForOne = Currency.unwrap(key.currency0) == IMD;
            uint160 limit = zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341;
            delta = manager.swap(key, SwapParams(zeroForOne, -100 ether, limit), "");
        } else {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, 1e24, 0), "");
        }
        settle(key.currency0, delta.amount0());
        settle(key.currency1, delta.amount1());
        return "";
    }

    function settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            manager.sync(currency);
            require(IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(delta))));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, address(this), uint256(int256(delta)));
        }
    }
}

contract FirstBuyProof is ProofFixtureFirstBuy {
    function test_firstBuyCanPayFeesInSameSwapWithoutExternalBacking() public {
        bool paperIs0 = Currency.unwrap(key.currency0) == address(paper);
        seed(paperIs0 ? int24(60) : int24(-120), paperIs0 ? int24(120) : int24(-60));
        assertGt(paper.balanceOf(address(manager)), 0);
        assertEq(IERC20(IMD).balanceOf(address(manager)), 0);
        uint256 paperBefore = paper.balanceOf(address(this));
        buy();
        assertGt(paper.balanceOf(address(this)), paperBefore);
        assertEq(IERC20(IMD).balanceOf(ORDERS), 0.5 ether);
        assertEq(IERC20(IMD).balanceOf(DEV), 1.5 ether);
        assertEq(IERC20(IMD).balanceOf(address(hook)), 0);
    }
}

// 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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {HookFlags} from "src/HookFlags.sol";

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

/// @notice Reproduces the launch flow the manifest describes: deploy `hook.contract` (PaperHook) with
/// constructorArgs ["$poolManager"] at an address carrying the declared 14 flags, then initialize the
/// Paper/IMD pool in the same transaction. The deployed artifact is the disabled implementation: its
/// namespaced `manager` is zero and `initialize` is permanently disabled, so `beforeInitialize`
/// reverts `Unauthorized` for the PoolManager and the pool can never be created.
contract ManifestHookCannotLaunchTest is Test {
    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    PoolManager manager;
    Paper paper;
    address hook;

    function setUp() public {
        manager = new PoolManager(address(this));
        paper = new Paper();
        vm.etch(IMD, address(new ImdStub()).code);

        // Exactly what the manifest tells the deployer: creationCode(PaperHook) ++ abi.encode($poolManager).
        bytes memory creationCode = abi.encodePacked(type(PaperHook).creationCode, abi.encode(IPoolManager(manager)));
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i; i < 500_000; ++i) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.ALL)) continue;
            bytes32 salt = bytes32(i);
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            require(at == predicted, "deploy failed");
            hook = at;
            break;
        }
        require(hook != address(0), "no salt");
    }

    function _key() internal view returns (PoolKey memory) {
        (address a, address b) = address(paper) < IMD ? (address(paper), IMD) : (IMD, address(paper));
        return PoolKey(Currency.wrap(a), Currency.wrap(b), 3000, 60, IHooks(hook));
    }

    /// The hook the manifest names reports all 14 permissions and is placed on a matching address,
    /// but it cannot bring up its own pool: there is no deployment path in which the artifact named by
    /// `hook.contract` is a working hook.
    function test_manifestHookInitializesItsPool() public {
        Hooks.Permissions memory p = PaperHook(hook).getHookPermissions();
        assertTrue(p.beforeInitialize, "declares beforeInitialize");
        assertEq(HookFlags.flagsOf(hook), HookFlags.ALL, "address carries the declared flags");

        // Expected: the factory's pool initialization succeeds in the same transaction as the hook deployment.
        // Actual: beforeInitialize's onlyManager compares msg.sender to the zero namespaced manager and reverts.
        manager.initialize(_key(), Q96);
        assertTrue(PaperHook(hook).poolKey().fee == 3000, "pool bound");
    }

    /// The artifact can never be configured afterwards either: the constructor disabled its initializer.
    function test_manifestHookCanBeConfiguredAfterDeployment() public {
        PaperHook(hook).initialize(address(paper), address(this), 1 ether);
        assertEq(PaperHook(hook).owner(), address(this));
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";
import {PaperSwapRouter} from "src/PaperSwapRouter.sol";

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

/// @dev Minimal liquidity helper so the test can seed a one-sided position through the real PoolManager.
contract ScratchLp is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager internal immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function liquidity(PoolKey memory key, ModifyLiquidityParams memory params) external {
        manager.unlock(abi.encode(msg.sender, key, params));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager");
        (address payer, PoolKey memory key, ModifyLiquidityParams memory params) =
            abi.decode(data, (address, PoolKey, ModifyLiquidityParams));
        (BalanceDelta delta,) = manager.modifyLiquidity(key, params, "");
        _settle(key.currency0, delta.amount0(), payer);
        _settle(key.currency1, delta.amount1(), payer);
        return "";
    }

    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transferFrom(payer, address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, payer, uint256(int256(delta)));
        }
    }
}

/// @notice The launch seeds paper only (poolBps 8000, no IMD). A paper-only position lies entirely on one side of
/// the initial price, so the pool's active liquidity is zero until the first buy moves the price into the range.
/// postFeeTokens() refuses zero active liquidity, so postDraft() is unusable in exactly the state the launch creates,
/// although slot0 holds the initial price and buyers can already trade at it.
contract LaunchStateQuoteTest is Test {
    using StateLibrary for IPoolManager;

    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    Paper internal paper;
    PoolManager internal manager;
    PaperDeployment internal deployer;
    PaperHook internal hook;
    PoolKey internal key;
    ScratchLp internal lp;
    PaperSwapRouter internal router;
    bool internal paperIs0;

    function setUp() public {
        deployCodeTo("Paper.sol:Paper", address(0x100000));
        paper = Paper(address(0x100000));
        vm.etch(IMD, address(new ScratchImd()).code);
        deal(IMD, address(this), 1e30, true);
        manager = new PoolManager(address(this));
        deployer = new PaperDeployment();
        PaperHook implementation = new PaperHook(manager);
        PaperDeployment.Config memory config =
            PaperDeployment.Config(manager, address(paper), address(this), 1 ether, Q96, 3000, 60);
        bytes32 hash = keccak256(deployer.proxyInitCode(address(implementation), config));
        (bytes32 salt,) = deployer.mine(address(deployer), hash, 0, 200_000);
        hook = deployer.deployHook(salt, address(implementation), config);
        key = hook.poolKey();
        paperIs0 = Currency.unwrap(key.currency0) == address(paper);
        lp = new ScratchLp(manager);
        router = new PaperSwapRouter(hook);
        paper.approve(address(lp), type(uint256).max);
        paper.approve(address(hook), type(uint256).max);
        paper.approve(address(router), type(uint256).max);
        IERC20(IMD).approve(address(router), type(uint256).max);
        // Launch state: paper-only liquidity beside the initial price, the same shape as the project's own
        // test_freshTokenOnlyPoolNeedsPrepaidImdFee. No IMD is deposited.
        lp.liquidity(
            key, ModifyLiquidityParams(paperIs0 ? int24(60) : int24(-120), paperIs0 ? int24(120) : int24(-60), 1e24, 0)
        );
        assertGt(paper.balanceOf(address(manager)), 0);
        assertEq(IERC20(IMD).balanceOf(address(manager)), 0);
        (uint160 sqrtPrice,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(sqrtPrice, Q96);
        assertEq(IPoolManager(address(manager)).getLiquidity(key.toId()), 0);
    }

    /// @dev Fails on the current code: postFeeTokens() reverts PoolUnavailable in the launch state.
    /// Passes once the quote is taken from slot0 without requiring non-zero active liquidity.
    function test_postDraftWorksInPaperOnlyLaunchState() public {
        uint256 quote = hook.postFeeTokens();
        assertEq(quote, 1 ether, "1 USD at 1 USD/IMD and raw price 1:1 is 1e18 paper");
        assertEq(hook.postDraft(keccak256("launch day draft")), 1);
        assertEq(paper.balanceOf(DEAD), 1 ether);
    }

    /// @dev Sanity: the same pool quotes and trades as soon as one buy has moved the price into the range.
    function test_sanity_quoteWorksAfterFirstBuy() public {
        uint160 limit = paperIs0 ? TickMath.MAX_SQRT_PRICE - 1 : TickMath.MIN_SQRT_PRICE + 1;
        router.swap(SwapParams(!paperIs0, -int256(1 ether), limit), 1 ether, 0, address(this), block.timestamp);
        assertGt(IPoolManager(address(manager)).getLiquidity(key.toId()), 0);
        assertGt(hook.postFeeTokens(), 0);
        assertEq(hook.postDraft(keccak256("after first buy")), 1);
    }
}

// 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 {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 {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";

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

/// @notice The launch factory deploys launch.json's hook.contract (PaperHook) with constructorArgs
/// ["$poolManager"] at an address mined for the declared flags, then initializes the pool in the same
/// transaction. This test does exactly that and expects the pool to come up.
contract ManifestLaunchProof is Test {
    using StateLibrary for IPoolManager;

    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    function test_manifestHookContractCanInitializeItsPool() public {
        PoolManager manager = new PoolManager(address(this));
        vm.etch(IMD, type(ImdMockForLaunch).runtimeCode);
        Paper paper = new Paper();

        // Mine the hook.contract creation code for all fourteen flags, as the factory does.
        bytes memory creation = abi.encodePacked(type(PaperHook).creationCode, abi.encode(manager));
        bytes32 initHash = keccak256(creation);
        address hook;
        for (uint256 i; i < 300_000; ++i) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))));
            if (uint160(predicted) & 0x3fff != 0x3fff) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                hook := create2(0, add(creation, 0x20), mload(creation), salt)
            }
            break;
        }
        assertTrue(hook != address(0), "hook deployment failed");
        assertEq(uint160(hook) & 0x3fff, 0x3fff);

        (address a, address b) = address(paper) < IMD ? (address(paper), IMD) : (IMD, address(paper));
        PoolKey memory key = PoolKey(Currency.wrap(a), Currency.wrap(b), 3000, 60, IHooks(hook));

        // Expected: the factory's single transaction initializes the pool. Actual: beforeInitialize
        // reverts Unauthorized because the standalone implementation's namespaced manager is zero and
        // its initializer is disabled, so the launch transaction cannot succeed.
        manager.initialize(key, Q96);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(price, Q96, "pool was not initialized");
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";

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

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

/// @notice The ordinary v4 settlement order: swap (or modify liquidity) first, then pay what the
/// resulting delta says is owed. Uniswap's Universal Router (V4_SWAP: SWAP_EXACT_IN_SINGLE,
/// SETTLE_ALL, TAKE_ALL) settles in this order.
contract SettleAfterRouter is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function swap(PoolKey memory key, SwapParams memory params) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(0), msg.sender, key, abi.encode(params))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, ModifyLiquidityParams memory params) external {
        manager.unlock(abi.encode(uint8(1), msg.sender, key, abi.encode(params)));
    }

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

    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transferFrom(payer, address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, payer, uint256(int256(delta)));
        }
    }
}

contract FirstBuyProof is Test {
    using BalanceDeltaLibrary for BalanceDelta;

    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address internal constant DEV = 0xb59eac9882Ba98f4170d99D5F402C3EDb6D50D75;
    address internal constant ORDERS = 0x721F8232e19c92516eB753FEF53d8A33a3637989;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    PoolManager internal manager;
    IERC20 internal imd;
    Paper internal paper;
    PaperHook internal hook;
    PoolKey internal key;
    SettleAfterRouter internal router;
    bool internal paperIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, type(ImdMockForFirstBuy).runtimeCode);
        ImdMockForFirstBuy(IMD).mint(address(this), 1e30);
        imd = IERC20(IMD);
        paper = new Paper();
        PaperDeployment deployer = new PaperDeployment();
        PaperHook implementation = new PaperHook(manager);

        PaperDeployment.Config memory config =
            PaperDeployment.Config(manager, address(paper), address(this), 1 ether, Q96, 3000, 60);
        bytes32 hash = keccak256(deployer.proxyInitCode(address(implementation), config));
        (bytes32 salt,) = deployer.mine(address(deployer), hash, 0, 200_000);
        hook = deployer.deployHook(salt, address(implementation), config);
        key = hook.poolKey();

        router = new SettleAfterRouter(manager);
        paper.approve(address(router), type(uint256).max);
        imd.approve(address(router), type(uint256).max);
        paperIs0 = Currency.unwrap(key.currency0) == address(paper);

        // Launch seeding: paper only, in a range above the current price. No IMD anywhere in the manager.
        router.addLiquidity(
            key, ModifyLiquidityParams(paperIs0 ? int24(60) : int24(-120), paperIs0 ? int24(120) : int24(-60), 1e24, 0)
        );
    }

    function test_firstBuyOnFreshManagerWithSettleAfterRouter() public {
        assertGt(paper.balanceOf(address(manager)), 0, "pool holds paper");
        assertEq(imd.balanceOf(address(manager)), 0, "fresh manager holds no IMD");

        // A buyer spends 100 IMD exact input through the ordinary settle-after order.
        bool zeroForOne = !paperIs0;
        uint160 limit = zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341;
        BalanceDelta delta = router.swap(key, SwapParams(zeroForOne, -100 ether, limit));

        // Expected: the trade succeeds and the 2 IMD fee reaches both wallets in the same swap.
        // Actual on the current code: beforeSwap's _pay reverts InsufficientFeeBacking because the
        // manager's physical IMD balance is zero while the buyer's input is still unsettled.
        int128 paperOut = paperIs0 ? delta.amount0() : delta.amount1();
        assertGt(paperOut, 0, "buyer received no paper");
        assertEq(imd.balanceOf(ORDERS), 0.5 ether, "orders wallet fee");
        assertEq(imd.balanceOf(DEV), 1.5 ether, "dev wallet fee");
        assertEq(imd.balanceOf(address(manager)), 98 ether, "manager keeps the net 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 {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 {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {HookFlags} from "src/HookFlags.sol";

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

/// launch.json: hook.contract = "PaperHook", constructorArgs = ["$poolManager"].
/// The deployer therefore deploys PaperHook's creation code with the chain's PoolManager at an address carrying
/// all 14 flags, then initializes the paper/IMD pool. That pool initialization must succeed for the launch to exist.
contract ManifestHookProofTest is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    function test_manifestHookDeployedWithPoolManagerOnlyCanHostThePool() public {
        PoolManager manager = new PoolManager(address(this));
        Paper paper = new Paper();
        vm.etch(IMD, address(new ProofImd()).code);

        bytes memory creation = abi.encodePacked(type(PaperHook).creationCode, abi.encode(address(manager)));
        bytes32 initHash = keccak256(creation);
        address at;
        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.ALL)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creation, 0x20), mload(creation), salt)
            }
            break;
        }
        require(at != address(0), "no salt produced an all-flags address");
        assertEq(HookFlags.flagsOf(at), HookFlags.ALL);
        // The protected admission checks pass on this code: it declares all flags and refuses outside callers.
        Hooks.Permissions memory p = PaperHook(at).getHookPermissions();
        assertTrue(p.beforeInitialize);

        (address a, address b) = address(paper) < IMD ? (address(paper), IMD) : (IMD, address(paper));
        PoolKey memory key = PoolKey(Currency.wrap(a), Currency.wrap(b), 3000, 60, IHooks(at));

        // FAILS on the current tree: PaperHook's constructor disables initialization, its namespaced manager is
        // zero, and beforeInitialize reverts Unauthorized for the real PoolManager, so the launch pool cannot be created.
        manager.initialize(key, Q96);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(price, Q96, "the manifest hook must be able to initialize the launch pool");
    }
}

// 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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {HookFlags} from "src/HookFlags.sol";

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

/// launch.json: hook.contract = "PaperHook", constructorArgs = ["$poolManager"].
/// The deployer therefore deploys PaperHook's creation code with the chain's PoolManager at an address carrying
/// all 14 flags, then initializes the paper/IMD pool. That pool initialization must succeed for the launch to exist.
contract ManifestHookProofTest is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    function test_manifestHookDeployedWithPoolManagerOnlyCanHostThePool() public {
        PoolManager manager = new PoolManager(address(this));
        Paper paper = new Paper();
        vm.etch(IMD, address(new ProofImd()).code);

        bytes memory creation = abi.encodePacked(type(PaperHook).creationCode, abi.encode(address(manager)));
        bytes32 initHash = keccak256(creation);
        address at;
        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.ALL)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creation, 0x20), mload(creation), salt)
            }
            break;
        }
        require(at != address(0), "no salt produced an all-flags address");
        assertEq(HookFlags.flagsOf(at), HookFlags.ALL);
        // The protected admission checks pass on this code: it declares all flags and refuses outside callers.
        Hooks.Permissions memory p = PaperHook(at).getHookPermissions();
        assertTrue(p.beforeInitialize);

        (address a, address b) = address(paper) < IMD ? (address(paper), IMD) : (IMD, address(paper));
        PoolKey memory key = PoolKey(Currency.wrap(a), Currency.wrap(b), 3000, 60, IHooks(at));

        // FAILS on the current tree: PaperHook's constructor disables initialization, its namespaced manager is
        // zero, and beforeInitialize reverts Unauthorized for the real PoolManager, so the launch pool cannot be created.
        manager.initialize(key, Q96);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(price, Q96, "the manifest hook must be able to initialize the launch pool");
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";

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

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

/// @notice The ordinary v4 settlement order: swap (or modify liquidity) first, then pay what the
/// resulting delta says is owed. Uniswap's Universal Router (V4_SWAP: SWAP_EXACT_IN_SINGLE,
/// SETTLE_ALL, TAKE_ALL) settles in this order.
contract SettleAfterRouter is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function swap(PoolKey memory key, SwapParams memory params) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(0), msg.sender, key, abi.encode(params))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, ModifyLiquidityParams memory params) external {
        manager.unlock(abi.encode(uint8(1), msg.sender, key, abi.encode(params)));
    }

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

    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transferFrom(payer, address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, payer, uint256(int256(delta)));
        }
    }
}

contract FirstBuyProof is Test {
    using BalanceDeltaLibrary for BalanceDelta;

    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address internal constant DEV = 0xb59eac9882Ba98f4170d99D5F402C3EDb6D50D75;
    address internal constant ORDERS = 0x721F8232e19c92516eB753FEF53d8A33a3637989;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    PoolManager internal manager;
    IERC20 internal imd;
    Paper internal paper;
    PaperHook internal hook;
    PoolKey internal key;
    SettleAfterRouter internal router;
    bool internal paperIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, type(ImdMockForFirstBuy).runtimeCode);
        ImdMockForFirstBuy(IMD).mint(address(this), 1e30);
        imd = IERC20(IMD);
        paper = new Paper();
        PaperDeployment deployer = new PaperDeployment();
        PaperHook implementation = new PaperHook(manager);

        PaperDeployment.Config memory config =
            PaperDeployment.Config(manager, address(paper), address(this), 1 ether, Q96, 3000, 60);
        bytes32 hash = keccak256(deployer.proxyInitCode(address(implementation), config));
        (bytes32 salt,) = deployer.mine(address(deployer), hash, 0, 200_000);
        hook = deployer.deployHook(salt, address(implementation), config);
        key = hook.poolKey();

        router = new SettleAfterRouter(manager);
        paper.approve(address(router), type(uint256).max);
        imd.approve(address(router), type(uint256).max);
        paperIs0 = Currency.unwrap(key.currency0) == address(paper);

        // Launch seeding: paper only, in a range above the current price. No IMD anywhere in the manager.
        router.addLiquidity(
            key, ModifyLiquidityParams(paperIs0 ? int24(60) : int24(-120), paperIs0 ? int24(120) : int24(-60), 1e24, 0)
        );
    }

    function test_firstBuyOnFreshManagerWithSettleAfterRouter() public {
        assertGt(paper.balanceOf(address(manager)), 0, "pool holds paper");
        assertEq(imd.balanceOf(address(manager)), 0, "fresh manager holds no IMD");

        // A buyer spends 100 IMD exact input through the ordinary settle-after order.
        bool zeroForOne = !paperIs0;
        uint160 limit = zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341;
        BalanceDelta delta = router.swap(key, SwapParams(zeroForOne, -100 ether, limit));

        // Expected: the trade succeeds and the 2 IMD fee reaches both wallets in the same swap.
        // Actual on the current code: beforeSwap's _pay reverts InsufficientFeeBacking because the
        // manager's physical IMD balance is zero while the buyer's input is still unsettled.
        int128 paperOut = paperIs0 ? delta.amount0() : delta.amount1();
        assertGt(paperOut, 0, "buyer received no paper");
        assertEq(imd.balanceOf(ORDERS), 0.5 ether, "orders wallet fee");
        assertEq(imd.balanceOf(DEV), 1.5 ether, "dev wallet fee");
        assertEq(imd.balanceOf(address(manager)), 98 ether, "manager keeps the net 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";

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

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

contract LiquidityRouterLS is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function addLiquidity(PoolKey memory key, ModifyLiquidityParams memory params) external {
        manager.unlock(abi.encode(msg.sender, key, params));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "Only manager");
        (address payer, PoolKey memory key, ModifyLiquidityParams memory params) =
            abi.decode(data, (address, PoolKey, ModifyLiquidityParams));
        (BalanceDelta delta,) = manager.modifyLiquidity(key, params, "");
        _settle(key.currency0, delta.amount0(), payer);
        _settle(key.currency1, delta.amount1(), payer);
        return "";
    }

    function _settle(Currency c, int128 d, address payer) private {
        if (d < 0) {
            manager.sync(c);
            IERC20(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-int256(d)));
            manager.settle();
        } else if (d > 0) {
            manager.take(c, payer, uint256(int256(d)));
        }
    }
}

/// @notice The launch seeds paper only (poolBps 8000, no IMD). In v4 that is a single-sided position
/// strictly on one side of the initial tick, so active liquidity is 0 while slot0 holds the launch
/// price. postFeeTokens()/postDraft() refuse that state, so posting is dead from launch until the
/// first buy, and dies again whenever the price leaves every initialized range.
contract LaunchStatePostingProof is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint160 constant Q96 = 79228162514264337593543950336;

    PoolManager manager;
    Paper paper;
    PaperHook hook;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, type(ImdMockLS).runtimeCode);
        ImdMockLS(IMD).mint(address(this), 1e30);
        paper = new Paper();
        PaperDeployment d = new PaperDeployment();
        PaperHook impl = new PaperHook(manager);
        PaperDeployment.Config memory cfg =
            PaperDeployment.Config(manager, address(paper), address(this), 1 ether, Q96, 3000, 60);
        (bytes32 salt,) = d.mine(address(d), keccak256(d.proxyInitCode(address(impl), cfg)), 0, 200_000);
        hook = d.deployHook(salt, address(impl), cfg);
        key = hook.poolKey();
        LiquidityRouterLS router = new LiquidityRouterLS(manager);
        paper.approve(address(router), type(uint256).max);
        bool paperIs0 = Currency.unwrap(key.currency0) == address(paper);
        // Paper-only launch position: strictly above the current tick when paper is currency0, strictly below otherwise.
        router.addLiquidity(
            key, ModifyLiquidityParams(paperIs0 ? int24(60) : int24(-887220), paperIs0 ? int24(887220) : int24(-60), 1e24, 0)
        );
        paper.approve(address(hook), type(uint256).max);
    }

    function test_postingWorksAtLaunchPrice() public {
        (uint160 sqrtPrice,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(sqrtPrice, Q96, "launch price is readable");
        assertEq(IPoolManager(address(manager)).getLiquidity(key.toId()), 0, "paper-only seeding has no active liquidity");
        assertGt(paper.balanceOf(address(manager)), 0, "pool holds paper");

        // Expected: one USD of paper at the launch price (1 IMD = 1 USD, 1 paper = 1 IMD) is 1e18 paper,
        // and the post burns it. Actual on this tree: both calls revert PoolUnavailable().
        assertEq(hook.postFeeTokens(), 1e18, "quote at the launch price");
        uint256 before = paper.balanceOf(address(this));
        uint256 id = hook.postDraft(keccak256("first draft"));
        assertEq(id, 1);
        assertEq(before - paper.balanceOf(address(this)), 1e18, "burned the quoted amount");
        assertEq(paper.balanceOf(DEAD), 1e18);
    }
}

// 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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {HookFlags} from "src/HookFlags.sol";

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

/// launch.json: hook.contract = "PaperHook", constructorArgs = ["$poolManager"].
/// The deployer therefore deploys PaperHook's creation code with the chain's PoolManager at an address carrying
/// all 14 flags, then initializes the paper/IMD pool. That pool initialization must succeed for the launch to exist.
contract ManifestHookProofTest is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    function test_manifestHookDeployedWithPoolManagerOnlyCanHostThePool() public {
        PoolManager manager = new PoolManager(address(this));
        Paper paper = new Paper();
        vm.etch(IMD, address(new ProofImd()).code);

        bytes memory creation = abi.encodePacked(type(PaperHook).creationCode, abi.encode(address(manager)));
        bytes32 initHash = keccak256(creation);
        address at;
        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.ALL)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creation, 0x20), mload(creation), salt)
            }
            break;
        }
        require(at != address(0), "no salt produced an all-flags address");
        assertEq(HookFlags.flagsOf(at), HookFlags.ALL);
        // The protected admission checks pass on this code: it declares all flags and refuses outside callers.
        Hooks.Permissions memory p = PaperHook(at).getHookPermissions();
        assertTrue(p.beforeInitialize);

        (address a, address b) = address(paper) < IMD ? (address(paper), IMD) : (IMD, address(paper));
        PoolKey memory key = PoolKey(Currency.wrap(a), Currency.wrap(b), 3000, 60, IHooks(at));

        // FAILS on the current tree: PaperHook's constructor disables initialization, its namespaced manager is
        // zero, and beforeInitialize reverts Unauthorized for the real PoolManager, so the launch pool cannot be created.
        manager.initialize(key, Q96);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(price, Q96, "the manifest hook must be able to initialize the launch pool");
    }
}

// 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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "v4-core/src/types/BalanceDelta.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {PaperDeployment} from "src/PaperDeployment.sol";

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

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

/// @notice The ordinary v4 settlement order: swap (or modify liquidity) first, then pay what the
/// resulting delta says is owed. Uniswap's Universal Router (V4_SWAP: SWAP_EXACT_IN_SINGLE,
/// SETTLE_ALL, TAKE_ALL) settles in this order.
contract SettleAfterRouter is IUnlockCallback {
    using BalanceDeltaLibrary for BalanceDelta;

    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function swap(PoolKey memory key, SwapParams memory params) external returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(uint8(0), msg.sender, key, abi.encode(params))), (BalanceDelta));
    }

    function addLiquidity(PoolKey memory key, ModifyLiquidityParams memory params) external {
        manager.unlock(abi.encode(uint8(1), msg.sender, key, abi.encode(params)));
    }

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

    function _settle(Currency currency, int128 delta, address payer) private {
        if (delta < 0) {
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transferFrom(payer, address(manager), uint256(-int256(delta)));
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, payer, uint256(int256(delta)));
        }
    }
}

contract FirstBuyProof is Test {
    using BalanceDeltaLibrary for BalanceDelta;

    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    address internal constant DEV = 0xb59eac9882Ba98f4170d99D5F402C3EDb6D50D75;
    address internal constant ORDERS = 0x721F8232e19c92516eB753FEF53d8A33a3637989;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    PoolManager internal manager;
    IERC20 internal imd;
    Paper internal paper;
    PaperHook internal hook;
    PoolKey internal key;
    SettleAfterRouter internal router;
    bool internal paperIs0;

    function setUp() public {
        manager = new PoolManager(address(this));
        vm.etch(IMD, type(ImdMockForFirstBuy).runtimeCode);
        ImdMockForFirstBuy(IMD).mint(address(this), 1e30);
        imd = IERC20(IMD);
        paper = new Paper();
        PaperDeployment deployer = new PaperDeployment();
        PaperHook implementation = new PaperHook(manager);

        PaperDeployment.Config memory config =
            PaperDeployment.Config(manager, address(paper), address(this), 1 ether, Q96, 3000, 60);
        bytes32 hash = keccak256(deployer.proxyInitCode(address(implementation), config));
        (bytes32 salt,) = deployer.mine(address(deployer), hash, 0, 200_000);
        hook = deployer.deployHook(salt, address(implementation), config);
        key = hook.poolKey();

        router = new SettleAfterRouter(manager);
        paper.approve(address(router), type(uint256).max);
        imd.approve(address(router), type(uint256).max);
        paperIs0 = Currency.unwrap(key.currency0) == address(paper);

        // Launch seeding: paper only, in a range above the current price. No IMD anywhere in the manager.
        router.addLiquidity(
            key, ModifyLiquidityParams(paperIs0 ? int24(60) : int24(-120), paperIs0 ? int24(120) : int24(-60), 1e24, 0)
        );
    }

    function test_firstBuyOnFreshManagerWithSettleAfterRouter() public {
        assertGt(paper.balanceOf(address(manager)), 0, "pool holds paper");
        assertEq(imd.balanceOf(address(manager)), 0, "fresh manager holds no IMD");

        // A buyer spends 100 IMD exact input through the ordinary settle-after order.
        bool zeroForOne = !paperIs0;
        uint160 limit = zeroForOne ? 4295128740 : 1461446703485210103287273052203988822378723970341;
        BalanceDelta delta = router.swap(key, SwapParams(zeroForOne, -100 ether, limit));

        // Expected: the trade succeeds and the 2 IMD fee reaches both wallets in the same swap.
        // Actual on the current code: beforeSwap's _pay reverts InsufficientFeeBacking because the
        // manager's physical IMD balance is zero while the buyer's input is still unsettled.
        int128 paperOut = paperIs0 ? delta.amount0() : delta.amount1();
        assertGt(paperOut, 0, "buyer received no paper");
        assertEq(imd.balanceOf(ORDERS), 0.5 ether, "orders wallet fee");
        assertEq(imd.balanceOf(DEV), 1.5 ether, "dev wallet fee");
        assertEq(imd.balanceOf(address(manager)), 98 ether, "manager keeps the net 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 {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 {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {Paper} from "src/Paper.sol";
import {PaperHook} from "src/PaperHook.sol";
import {HookFlags} from "src/HookFlags.sol";

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

/// launch.json: hook.contract = "PaperHook", constructorArgs = ["$poolManager"].
/// The deployer therefore deploys PaperHook's creation code with the chain's PoolManager at an address carrying
/// all 14 flags, then initializes the paper/IMD pool. That pool initialization must succeed for the launch to exist.
contract ManifestHookProofTest is Test {
    using StateLibrary for IPoolManager;

    address constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 constant Q96 = 79228162514264337593543950336;

    function test_manifestHookDeployedWithPoolManagerOnlyCanHostThePool() public {
        PoolManager manager = new PoolManager(address(this));
        Paper paper = new Paper();
        vm.etch(IMD, address(new ProofImd()).code);

        bytes memory creation = abi.encodePacked(type(PaperHook).creationCode, abi.encode(address(manager)));
        bytes32 initHash = keccak256(creation);
        address at;
        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.ALL)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creation, 0x20), mload(creation), salt)
            }
            break;
        }
        require(at != address(0), "no salt produced an all-flags address");
        assertEq(HookFlags.flagsOf(at), HookFlags.ALL);
        // The protected admission checks pass on this code: it declares all flags and refuses outside callers.
        Hooks.Permissions memory p = PaperHook(at).getHookPermissions();
        assertTrue(p.beforeInitialize);

        (address a, address b) = address(paper) < IMD ? (address(paper), IMD) : (IMD, address(paper));
        PoolKey memory key = PoolKey(Currency.wrap(a), Currency.wrap(b), 3000, 60, IHooks(at));

        // FAILS on the current tree: PaperHook's constructor disables initialization, its namespaced manager is
        // zero, and beforeInitialize reverts Unauthorized for the real PoolManager, so the launch pool cannot be created.
        manager.initialize(key, Q96);
        (uint160 price,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        assertEq(price, Q96, "the manifest hook must be able to initialize the launch pool");
    }
}