// 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 {SovrnHook} from "src/SovrnHook.sol";
import {SovrnToken} from "src/SovrnToken.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Reproduces the admission floor's `setUp` (Hook.protected.t.sol): a local PoolManager, the launch
///         token deployed with its constructor run, a factory probe, and the hook CREATE2-deployed at an
///         address carrying flags 8396. The floor never sets the chain id and never puts code at IMD's
///         address before it deploys the hook, so SovrnHook's constructor must survive without either.
contract FloorDeployTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant FACTORY_PROBE = address(0xFAC70);

    PoolManager manager;
    SovrnToken token;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new SovrnToken();
    }

    function _creationCode() internal view returns (bytes memory) {
        return abi.encodePacked(
            type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, FACTORY_PROBE)
        );
    }

    /// @dev Same loop as HookProtectedTest.deployAtFlags: mine a salt, CREATE2, require non-zero.
    function _deployAtFlags(bytes memory creationCode, uint160 flags) internal returns (address at) {
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, flags)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            return at;
        }
        revert("no salt produced an address carrying the declared flags");
    }

    /// @notice The floor's environment as it is: default chain id, no code at IMD.
    function test_floorEnvironment_hookDeploys() public {
        assertEq(IMD.code.length, 0, "precondition: the floor has not put code at IMD before setUp");
        address at = _deployAtFlags(_creationCode(), HookFlags.SOVRN_FLAGS);
        assertTrue(at != address(0), "hook deployment reverted (the admission floor's setUp fails here)");
        assertGt(at.code.length, 0);
    }

    /// @notice Only the chain id differs from the launch chain; IMD has code.
    function test_wrongChainIdAlone_hookDeploys() public {
        vm.etch(IMD, address(token).code);
        vm.chainId(31337);
        address at = _deployAtFlags(_creationCode(), HookFlags.SOVRN_FLAGS);
        assertTrue(at != address(0), "hook deployment reverted on chain id 31337");
    }

    /// @notice Only the IMD code is missing; the chain id is the launch chain's.
    function test_noImdCodeAlone_hookDeploys() public {
        vm.chainId(4663);
        assertEq(IMD.code.length, 0);
        address at = _deployAtFlags(_creationCode(), HookFlags.SOVRN_FLAGS);
        assertTrue(at != address(0), "hook deployment reverted without code at IMD");
    }

    /// @notice Control: with both conditions satisfied the same deployment succeeds.
    function test_control_launchChainWithImdCode_hookDeploys() public {
        vm.chainId(4663);
        vm.etch(IMD, address(token).code);
        address at = _deployAtFlags(_creationCode(), HookFlags.SOVRN_FLAGS);
        assertTrue(at != address(0));
        assertGt(at.code.length, 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 {SovrnHook} from "src/SovrnHook.sol";
import {SovrnToken} from "src/SovrnToken.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Mirrors what the admission floor (Hook.protected.t.sol, setUp + deployAtFlags) does to the attested
///         creation code: a local PoolManager, the launch token deployed first, then CREATE2 of the hook at an
///         address carrying flags 8396. The floor runs on a plain local EVM: the default chain id and no code at
///         the IMD constant. SovrnHook's constructor reverts there (`WrongChain`, then `IMD.code.length == 0`),
///         so CREATE2 returns zero and every floor test fails in setUp with "hook deployment reverted".
///         Passes once the chain-id gate and the IMD code checks (hook and vault constructors) are removed.
contract HookDeploysOnAdmissionFloorTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant FACTORY_PROBE = 0x00000000000000000000000000000000000C0003;

    function test_hookCreationCodeDeploysOnThePlainLocalEvmTheFloorUses() public {
        // The floor's environment: nothing etched at IMD, chain id left at forge's default.
        assertEq(IMD.code.length, 0, "precondition: the floor has no code at IMD");
        assertTrue(block.chainid != 4663, "precondition: the floor does not run on chain 4663");

        PoolManager manager = new PoolManager(address(this));
        SovrnToken token = new SovrnToken();
        bytes memory creationCode =
            abi.encodePacked(type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, FACTORY_PROBE));

        address at = deployAtFlags(creationCode, HookFlags.SOVRN_FLAGS);
        assertEq(HookFlags.flagsOf(at), 8396);
        assertEq(address(SovrnHook(at).vault().token()), address(token));
    }

    /// @dev Verbatim logic of the floor's deployAtFlags: mine a salt, CREATE2, require a non-zero address.
    function deployAtFlags(bytes memory creationCode, uint160 flags) internal returns (address at) {
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, flags)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            require(at != address(0), "hook deployment reverted");
            return at;
        }
        revert("no salt produced an address carrying the declared flags");
    }
}

// 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 {SovrnHook} from "src/SovrnHook.sol";
import {SovrnToken} from "src/SovrnToken.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Mirrors the admission floor's setUp (Hook.protected.t.sol): the attested creation code is
///         deployed by CREATE2 on a plain local EVM (default chain id, no code at the IMD address).
///         The floor requires `at != address(0)`; SovrnHook's constructor reverts here (WrongChain, and
///         Unauthorized because IMD has no code), so every floor test fails in setUp.
contract FloorDeployTest is Test {
    function test_hookCreationCodeDeploysOnPlainLocalEvmLikeTheAdmissionFloor() public {
        PoolManager manager = new PoolManager(address(this));
        SovrnToken token = new SovrnToken();
        address factoryProbe = address(0xFAC7);
        bytes memory creationCode =
            abi.encodePacked(type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, factoryProbe));

        // Preconditions the floor runs under (it never sets a chain id or puts code at IMD).
        assertEq(block.chainid, 31337, "floor runs at the default chain id");
        assertEq(address(0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127).code.length, 0, "no IMD code on a plain EVM");

        bytes32 initCodeHash = keccak256(creationCode);
        address at;
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash)))));
            if (!HookFlags.matches(predicted, HookFlags.SOVRN_FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            break;
        }
        assertTrue(at != address(0), "hook deployment reverted (the admission floor's setUp requires this to succeed)");
    }

    /// @dev Control: with chain id 4663 and code at IMD the same creation code deploys, so the two
    ///      constructor gates are the only cause.
    function test_controlDeploysOnceChainIdAndImdCodeArePresent() public {
        vm.chainId(4663);
        vm.etch(0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127, hex"00");
        PoolManager manager = new PoolManager(address(this));
        SovrnToken token = new SovrnToken();
        bytes memory creationCode =
            abi.encodePacked(type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, address(0xFAC7)));
        bytes32 initCodeHash = keccak256(creationCode);
        address at;
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash)))));
            if (!HookFlags.matches(predicted, HookFlags.SOVRN_FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            break;
        }
        assertTrue(at != address(0), "control deployment should succeed");
    }
}

// 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 {SovrnToken} from "src/SovrnToken.sol";
import {SovrnHook} from "src/SovrnHook.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice Reproduces the admission floor's `setUp` (Hook.protected.t.sol): the attested creation code is
///         deployed by CREATE2 at a mined flags address on a local EVM with the default chain id (31337) and
///         no code at IMD. The constructor's `block.chainid != 4663` and `IMD.code.length == 0` gates make
///         CREATE2 return zero, so the floor's `require(at != address(0), "hook deployment reverted")` fails
///         and no floor test can run. Fails on the code as it is; passes once the constructor gates are dropped.
contract FloorDeployTest is Test {
    uint160 internal constant FLAGS = 8396;

    function test_hookDeploysUnderTheAdmissionFloorEnvironment() public {
        // Exactly what the floor does: a fresh manager, the launch token at its probe, the floor as factory.
        assertEq(block.chainid, 31337, "the floor runs with foundry's default chain id");
        PoolManager manager = new PoolManager(address(this));
        SovrnToken token = new SovrnToken();
        bytes memory creationCode =
            abi.encodePacked(type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, address(this)));

        address at = _deployAtFlags(creationCode, FLAGS);
        assertTrue(at != address(0), "hook deployment reverted");
        assertEq(HookFlags.flagsOf(at), FLAGS);
    }

    /// @dev Copied from the floor: mine a salt, CREATE2 the code, treat a zero result as a reverted constructor.
    function _deployAtFlags(bytes memory creationCode, uint160 flags) internal returns (address at) {
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, flags)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            return at;
        }
        revert("no salt produced an address carrying the declared flags");
    }
}

// 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 {SovrnHook} from "src/SovrnHook.sol";
import {SovrnToken} from "src/SovrnToken.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The admission floor (Hook.protected.t.sol) deploys the attested hook creation code with CREATE2 in
///         its setUp on a local EVM: default chain id (31337) and no code at the IMD address. SovrnHook's
///         constructor reverts there (WrongChain, then Unauthorized for IMD.code.length == 0, repeated in
///         LifeForceVault), so CREATE2 returns address(0) and every floor test fails before it starts.
///         This test mirrors that setUp exactly: a real PoolManager, the real token, CREATE2 from this
///         contract with a mined salt, default chain id, nothing at IMD. It fails on the code as it is and
///         passes once the constructor no longer requires chain id 4663 and code at IMD.
contract AdmissionGateProofTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    SovrnToken token;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new SovrnToken();
    }

    function _creationCode() internal view returns (bytes memory) {
        return abi.encodePacked(
            type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, address(this))
        );
    }

    /// @dev Same loop as the floor's deployAtFlags: mine a salt for flags 8396, then CREATE2 from this contract.
    function _deployAtFlags(bytes memory creationCode) internal returns (address at) {
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SOVRN_FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            return at;
        }
        revert("no salt produced an address carrying the declared flags");
    }

    /// @notice Default chain id, no code at IMD: exactly the floor's setUp. The hook must deploy.
    function test_hookDeploysOnTheAdmissionFloorEnvironment() public {
        assertEq(block.chainid, 31337, "forge default chain id, as the floor runs");
        assertEq(IMD.code.length, 0, "no code at IMD, as the floor runs");

        address hook = _deployAtFlags(_creationCode());
        assertTrue(hook != address(0), "hook deployment reverted: the floor's setUp fails here for every test");
        assertEq(HookFlags.flagsOf(hook), 8396);
        assertGt(address(SovrnHook(hook).vault()).code.length, 0, "the vault was not deployed");
    }

    /// @notice Chain id 4663 alone is not enough: the IMD code checks (hook and vault) must go too.
    function test_hookDeploysOnChain4663WithoutCodeAtIMD() public {
        vm.chainId(4663);
        assertEq(IMD.code.length, 0);
        address hook = _deployAtFlags(_creationCode());
        assertTrue(hook != address(0), "hook deployment reverted without code at IMD");
    }

    /// @notice After deploying on the floor's environment, the launch factory (this contract) can still open the
    ///         launch pool on it, as the floor's test_initializesFromTheLaunchFactory asks.
    function test_floorThenInitializeFromTheFactory() public {
        address hook = _deployAtFlags(_creationCode());
        assertTrue(hook != address(0), "hook deployment reverted");
        (address c0, address c1) = IMD < address(token) ? (IMD, address(token)) : (address(token), IMD);
        PoolKey memory key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12_500, 60, IHooks(hook));
        manager.initialize(key, SQRT_PRICE_1_1);
        assertTrue(SovrnHook(hook).initialized());
    }
}

// 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 {SovrnHook} from "src/SovrnHook.sol";
import {SovrnToken} from "src/SovrnToken.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice The admission floor (Hook.protected.t.sol) deploys the attested hook creation code with CREATE2 in
///         its setUp on a local EVM: default chain id (31337) and no code at the IMD address. SovrnHook's
///         constructor reverts there (WrongChain, then Unauthorized for IMD.code.length == 0, repeated in
///         LifeForceVault), so CREATE2 returns address(0) and every floor test fails before it starts.
///         This test mirrors that setUp exactly: a real PoolManager, the real token, CREATE2 from this
///         contract with a mined salt, default chain id, nothing at IMD. It fails on the code as it is and
///         passes once the constructor no longer requires chain id 4663 and code at IMD.
contract AdmissionGateProofTest is Test {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;

    PoolManager manager;
    SovrnToken token;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new SovrnToken();
    }

    function _creationCode() internal view returns (bytes memory) {
        return abi.encodePacked(
            type(SovrnHook).creationCode, abi.encode(IPoolManager(address(manager)), token, address(this))
        );
    }

    /// @dev Same loop as the floor's deployAtFlags: mine a salt for flags 8396, then CREATE2 from this contract.
    function _deployAtFlags(bytes memory creationCode) internal returns (address at) {
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 200_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, HookFlags.SOVRN_FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            return at;
        }
        revert("no salt produced an address carrying the declared flags");
    }

    /// @notice Default chain id, no code at IMD: exactly the floor's setUp. The hook must deploy.
    function test_hookDeploysOnTheAdmissionFloorEnvironment() public {
        assertEq(block.chainid, 31337, "forge default chain id, as the floor runs");
        assertEq(IMD.code.length, 0, "no code at IMD, as the floor runs");

        address hook = _deployAtFlags(_creationCode());
        assertTrue(hook != address(0), "hook deployment reverted: the floor's setUp fails here for every test");
        assertEq(HookFlags.flagsOf(hook), 8396);
        assertGt(address(SovrnHook(hook).vault()).code.length, 0, "the vault was not deployed");
    }

    /// @notice Chain id 4663 alone is not enough: the IMD code checks (hook and vault) must go too.
    function test_hookDeploysOnChain4663WithoutCodeAtIMD() public {
        vm.chainId(4663);
        assertEq(IMD.code.length, 0);
        address hook = _deployAtFlags(_creationCode());
        assertTrue(hook != address(0), "hook deployment reverted without code at IMD");
    }

    /// @notice After deploying on the floor's environment, the launch factory (this contract) can still open the
    ///         launch pool on it, as the floor's test_initializesFromTheLaunchFactory asks.
    function test_floorThenInitializeFromTheFactory() public {
        address hook = _deployAtFlags(_creationCode());
        assertTrue(hook != address(0), "hook deployment reverted");
        (address c0, address c1) = IMD < address(token) ? (IMD, address(token)) : (address(token), IMD);
        PoolKey memory key = PoolKey(Currency.wrap(c0), Currency.wrap(c1), 12_500, 60, IHooks(hook));
        manager.initialize(key, SQRT_PRICE_1_1);
        assertTrue(SovrnHook(hook).initialized());
    }
}