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

/// @notice Mirrors the protected floor (Hook.protected.t.sol `setUp`/`deployAtFlags`): the attested
/// creation code, with the manifest's literal canary 0x6265...d9a baked in as the second constructor
/// argument, is CREATE2-deployed on a chain that has no network and no code at that address.
/// The hook's constructor does `canary.canaryAddress()` unconditionally, so deployment reverts and
/// every protected hook check that depends on `hook` fails in setUp.
contract ConstructorOnEmptyChainTest is Test {
    address constant LIVE_CANARY = 0x626517225096671868609c1bBF9c1B416A4eFd9a;
    uint160 constant DECLARED_FLAGS = 0x20cc;

    function test_attestedCreationCodeDeploysWhereTheProtectedFloorRunsIt() public {
        // Same precondition as the verifier's local chain: nothing lives at the mainnet canary address.
        assertEq(LIVE_CANARY.code.length, 0, "fixture: verifier chain has no canary code");

        PoolManager manager = new PoolManager(address(this));
        bytes memory creationCode =
            abi.encodePacked(type(QuantumCanaryHook).creationCode, abi.encode(IPoolManager(address(manager)), IQuantumCanary(LIVE_CANARY)));
        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, DECLARED_FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            break;
        }
        // Protected floor: require(at != address(0), "hook deployment reverted")
        assertTrue(at != address(0), "hook deployment reverted: constructor read canaryAddress() on an empty account");
        assertEq(HookFlags.flagsOf(at), 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 {TickMath} from "v4-core/src/libraries/TickMath.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} from "v4-core/src/types/BalanceDelta.sol";
import {QuantumCanaryHook} from "src/QuantumCanaryHook.sol";
import {QuantumCanaryToken} from "src/QuantumCanaryToken.sol";
import {IQuantumCanary} from "src/IQuantumCanary.sol";

/// @dev Verbatim logic of the live observer at 0x626517225096671868609c1bBF9c1B416A4eFd9a
/// (source published by the requester at github.com/identity-md-launches/launch-1213-src-quantumcanary-sol):
/// isTripped() is a LIVE predicate on canaryAddress.balance, not a latch.
contract LiveLogicCanary is IQuantumCanary {
    address public immutable canaryAddress;
    uint256 public immutable thresholdWei;
    uint256 public highWaterMark;
    bool private tripRecorded;
    uint256 public trippedAt;

    constructor(address canary, uint256 thresholdWei_) {
        canaryAddress = canary;
        thresholdWei = thresholdWei_;
        highWaterMark = canary.balance;
    }

    function isTripped() external view returns (bool) {
        return canaryAddress.balance < thresholdWei && highWaterMark >= thresholdWei;
    }

    function poke() external {
        uint256 balance = canaryAddress.balance;
        uint256 mark = highWaterMark;
        if (balance > mark) {
            highWaterMark = balance;
            mark = balance;
        }
        if (!tripRecorded && balance < thresholdWei && mark >= thresholdWei) {
            tripRecorded = true;
            trippedAt = block.timestamp;
        }
    }
}

contract RefillRaceTest is Test {
    uint160 constant Q96 = 79228162514264337593543950336;
    IPoolManager manager;
    QuantumCanaryHook hook;
    QuantumCanaryToken token;
    LiveLogicCanary canary;
    PoolKey key;
    address bounty;

    receive() external payable {}

    function setUp() public {
        vm.deal(address(this), 10_000_000 ether);
        bounty = makeAddr("derived secp256k1 bounty address");
        token = new QuantumCanaryToken();
        manager = IPoolManager(address(new PoolManager(address(this))));
        canary = new LiveLogicCanary(bounty, 1 ether);
        hook = _mine();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, Q96);
        // Launch-style seeding: CANARY only, no ETH in the manager.
        _liquidity(-600, -60, 100_000 ether);
        assertEq(address(manager).balance, 0);
    }

    function _mine() internal returns (QuantumCanaryHook deployed) {
        bytes memory init = abi.encodePacked(type(QuantumCanaryHook).creationCode, abi.encode(manager, canary));
        bytes32 hash = keccak256(init);
        for (uint256 i; i < 300_000; ++i) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash)))));
            if (uint160(predicted) & 0x3fff == 0x20cc) {
                return new QuantumCanaryHook{salt: bytes32(i)}(manager, canary);
            }
        }
        revert("no salt");
    }

    function _liquidity(int24 lower, int24 upper, int256 amount) internal {
        manager.unlock(abi.encode(false, ModifyLiquidityParams(lower, upper, amount, bytes32(0)), SwapParams(false, 0, 0)));
    }

    function _swap(SwapParams memory p) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, ModifyLiquidityParams(0, 0, 0, bytes32(0)), p)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool swapping, ModifyLiquidityParams memory lp, SwapParams memory sp) =
            abi.decode(data, (bool, ModifyLiquidityParams, SwapParams));
        BalanceDelta delta;
        if (swapping) delta = manager.swap(key, sp, "");
        else (delta,) = manager.modifyLiquidity(key, lp, "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency c, int128 amount) internal {
        if (amount < 0) {
            uint256 owed = uint256(-int256(amount));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: owed}();
            else {
                token.transfer(address(manager), owed);
                manager.settle();
            }
        } else if (amount > 0) {
            manager.take(c, address(this), uint256(int256(amount)));
        }
    }

    /// The bounty is armed (funded >= threshold and poked). The first launch buy accrues 1 ETH of
    /// claims because the manager held no ETH during the callback. A quantum attacker then drains
    /// the bounty: isTripped() == true. Before any swap observes it, anyone calls payout(): the
    /// hook's own 1 ETH refill pushes the balance back over the threshold, isTripped() flips to
    /// false, and the next swap still charges the bounty fee to the now attacker-controlled address.
    function test_payoutRefillClearsLiveAlarmBeforeHookObservesIt() public {
        vm.deal(bounty, 1 ether);
        canary.poke();
        assertFalse(canary.isTripped());

        // First buy on the fresh pool: fee 1 ETH accrues as claims (manager had no ETH in afterSwap).
        _swap(SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(hook.accruedFees(), 1 ether, "claims pending");
        assertEq(bounty.balance, 1 ether);

        // Quantum attacker drains the bounty.
        vm.deal(bounty, 0);
        assertTrue(canary.isTripped(), "live alarm is on");
        canary.poke();
        assertGt(canary.trippedAt(), 0, "observer records the trip permanently");

        // Anyone (or the attacker) calls the permissionless payout before a swap observes the trip.
        address anyone = makeAddr("anyone");
        vm.prank(anyone);
        assertEq(hook.payout(), 1 ether);
        assertEq(bounty.balance, 1 ether);
        assertFalse(canary.isTripped(), "hook's own refill cleared the live alarm");

        // Next swap: the hook should have retired; instead it charges the fee again.
        uint256 before = bounty.balance;
        _swap(SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        uint256 feeAfterTrip = bounty.balance - before + hook.accruedFees();
        emit log_named_uint("fee charged after recorded trip", feeAfterTrip);
        assertTrue(hook.retired(), "hook must retire after the recorded trip");
        assertEq(feeAfterTrip, 0, "no fee after a trip");
    }

    /// Control: the same drain, observed by a swap before any payout, retires the hook.
    function test_controlSwapBeforePayoutRetires() public {
        vm.deal(bounty, 1 ether);
        canary.poke();
        _swap(SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1));
        vm.deal(bounty, 0);
        _swap(SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertTrue(hook.retired());
    }
}

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

/// @notice Mirrors the protected floor (Hook.protected.t.sol `setUp`/`deployAtFlags`): the attested
/// creation code, with the manifest's literal canary 0x6265...d9a baked in as the second constructor
/// argument, is CREATE2-deployed on a chain that has no network and no code at that address.
/// The hook's constructor does `canary.canaryAddress()` unconditionally, so deployment reverts and
/// every protected hook check that depends on `hook` fails in setUp.
contract ConstructorOnEmptyChainTest is Test {
    address constant LIVE_CANARY = 0x626517225096671868609c1bBF9c1B416A4eFd9a;
    uint160 constant DECLARED_FLAGS = 0x20cc;

    function test_attestedCreationCodeDeploysWhereTheProtectedFloorRunsIt() public {
        // Same precondition as the verifier's local chain: nothing lives at the mainnet canary address.
        assertEq(LIVE_CANARY.code.length, 0, "fixture: verifier chain has no canary code");

        PoolManager manager = new PoolManager(address(this));
        bytes memory creationCode =
            abi.encodePacked(type(QuantumCanaryHook).creationCode, abi.encode(IPoolManager(address(manager)), IQuantumCanary(LIVE_CANARY)));
        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, DECLARED_FLAGS)) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            break;
        }
        // Protected floor: require(at != address(0), "hook deployment reverted")
        assertTrue(at != address(0), "hook deployment reverted: constructor read canaryAddress() on an empty account");
        assertEq(HookFlags.flagsOf(at), 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 {TickMath} from "v4-core/src/libraries/TickMath.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} from "v4-core/src/types/BalanceDelta.sol";
import {QuantumCanaryHook} from "src/QuantumCanaryHook.sol";
import {QuantumCanaryToken} from "src/QuantumCanaryToken.sol";
import {IQuantumCanary} from "src/IQuantumCanary.sol";

/// @dev Verbatim logic of the live observer at 0x626517225096671868609c1bBF9c1B416A4eFd9a
/// (source published by the requester at github.com/identity-md-launches/launch-1213-src-quantumcanary-sol):
/// isTripped() is a LIVE predicate on canaryAddress.balance, not a latch.
contract LiveLogicCanary is IQuantumCanary {
    address public immutable canaryAddress;
    uint256 public immutable thresholdWei;
    uint256 public highWaterMark;
    bool private tripRecorded;
    uint256 public trippedAt;

    constructor(address canary, uint256 thresholdWei_) {
        canaryAddress = canary;
        thresholdWei = thresholdWei_;
        highWaterMark = canary.balance;
    }

    function isTripped() external view returns (bool) {
        return canaryAddress.balance < thresholdWei && highWaterMark >= thresholdWei;
    }

    function poke() external {
        uint256 balance = canaryAddress.balance;
        uint256 mark = highWaterMark;
        if (balance > mark) {
            highWaterMark = balance;
            mark = balance;
        }
        if (!tripRecorded && balance < thresholdWei && mark >= thresholdWei) {
            tripRecorded = true;
            trippedAt = block.timestamp;
        }
    }
}

contract RefillRaceTest is Test {
    uint160 constant Q96 = 79228162514264337593543950336;
    IPoolManager manager;
    QuantumCanaryHook hook;
    QuantumCanaryToken token;
    LiveLogicCanary canary;
    PoolKey key;
    address bounty;

    receive() external payable {}

    function setUp() public {
        vm.deal(address(this), 10_000_000 ether);
        bounty = makeAddr("derived secp256k1 bounty address");
        token = new QuantumCanaryToken();
        manager = IPoolManager(address(new PoolManager(address(this))));
        canary = new LiveLogicCanary(bounty, 1 ether);
        hook = _mine();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, Q96);
        // Launch-style seeding: CANARY only, no ETH in the manager.
        _liquidity(-600, -60, 100_000 ether);
        assertEq(address(manager).balance, 0);
    }

    function _mine() internal returns (QuantumCanaryHook deployed) {
        bytes memory init = abi.encodePacked(type(QuantumCanaryHook).creationCode, abi.encode(manager, canary));
        bytes32 hash = keccak256(init);
        for (uint256 i; i < 300_000; ++i) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), hash)))));
            if (uint160(predicted) & 0x3fff == 0x20cc) {
                return new QuantumCanaryHook{salt: bytes32(i)}(manager, canary);
            }
        }
        revert("no salt");
    }

    function _liquidity(int24 lower, int24 upper, int256 amount) internal {
        manager.unlock(abi.encode(false, ModifyLiquidityParams(lower, upper, amount, bytes32(0)), SwapParams(false, 0, 0)));
    }

    function _swap(SwapParams memory p) internal returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(true, ModifyLiquidityParams(0, 0, 0, bytes32(0)), p)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool swapping, ModifyLiquidityParams memory lp, SwapParams memory sp) =
            abi.decode(data, (bool, ModifyLiquidityParams, SwapParams));
        BalanceDelta delta;
        if (swapping) delta = manager.swap(key, sp, "");
        else (delta,) = manager.modifyLiquidity(key, lp, "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency c, int128 amount) internal {
        if (amount < 0) {
            uint256 owed = uint256(-int256(amount));
            manager.sync(c);
            if (c.isAddressZero()) manager.settle{value: owed}();
            else {
                token.transfer(address(manager), owed);
                manager.settle();
            }
        } else if (amount > 0) {
            manager.take(c, address(this), uint256(int256(amount)));
        }
    }

    /// The bounty is armed (funded >= threshold and poked). The first launch buy accrues 1 ETH of
    /// claims because the manager held no ETH during the callback. A quantum attacker then drains
    /// the bounty: isTripped() == true. Before any swap observes it, anyone calls payout(): the
    /// hook's own 1 ETH refill pushes the balance back over the threshold, isTripped() flips to
    /// false, and the next swap still charges the bounty fee to the now attacker-controlled address.
    function test_payoutRefillClearsLiveAlarmBeforeHookObservesIt() public {
        vm.deal(bounty, 1 ether);
        canary.poke();
        assertFalse(canary.isTripped());

        // First buy on the fresh pool: fee 1 ETH accrues as claims (manager had no ETH in afterSwap).
        _swap(SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(hook.accruedFees(), 1 ether, "claims pending");
        assertEq(bounty.balance, 1 ether);

        // Quantum attacker drains the bounty.
        vm.deal(bounty, 0);
        assertTrue(canary.isTripped(), "live alarm is on");
        canary.poke();
        assertGt(canary.trippedAt(), 0, "observer records the trip permanently");

        // Anyone (or the attacker) calls the permissionless payout before a swap observes the trip.
        address anyone = makeAddr("anyone");
        vm.prank(anyone);
        assertEq(hook.payout(), 1 ether);
        assertEq(bounty.balance, 1 ether);
        assertFalse(canary.isTripped(), "hook's own refill cleared the live alarm");

        // Next swap: the hook should have retired; instead it charges the fee again.
        uint256 before = bounty.balance;
        _swap(SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        uint256 feeAfterTrip = bounty.balance - before + hook.accruedFees();
        emit log_named_uint("fee charged after recorded trip", feeAfterTrip);
        assertTrue(hook.retired(), "hook must retire after the recorded trip");
        assertEq(feeAfterTrip, 0, "no fee after a trip");
    }

    /// Control: the same drain, observed by a swap before any payout, retires the hook.
    function test_controlSwapBeforePayoutRetires() public {
        vm.deal(bounty, 1 ether);
        canary.poke();
        _swap(SwapParams(true, -100 ether, TickMath.MIN_SQRT_PRICE + 1));
        vm.deal(bounty, 0);
        _swap(SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertTrue(hook.retired());
    }
}