// 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 {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";

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

contract LaunchEpochDilutionTest is Test {
    address constant REQUESTER = address(0xB0B);

    function _salt(DeezLaunch l, address t, address r, address k) internal view returns (bytes32) {
        bytes32 h = keccak256(l.hookInitCode(t, r, k));
        for (uint256 i = 0; i < 400_000; i++) {
            address p = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), bytes32(i), h)))));
            if (uint160(p) & 0x3FFF == 0x20CC) return bytes32(i);
        }
        revert("no salt");
    }

    /// The factory deploys at the start of a UTC day; the requester calls `launch` 12 hours later. The
    /// launcher held the whole supply for those 12 hours, is not excluded, and has no claim path, so the
    /// launch day's pot is split as if 500,000,000 average $DEEZ were eligible holders.
    function test_launcherBalanceBeforeLaunchDilutesLaunchEpoch() public {
        vm.warp(20_000 days); // start of epoch 20000
        PoolManager manager = new PoolManager(address(this));
        PairToken imd = new PairToken();
        DeezLaunch launcher = new DeezLaunch(REQUESTER, IPoolManager(address(manager)), address(imd));
        DeezToken token = new DeezToken(address(launcher));
        DeezRewards rewards = new DeezRewards(address(token), address(imd), address(manager), address(launcher));
        DeezLiquidityLock lock = new DeezLiquidityLock(IPoolManager(address(manager)), address(rewards));
        bytes32 salt = _salt(launcher, address(token), address(rewards), address(lock));

        vm.warp(20_000 days + 12 hours);
        vm.prank(REQUESTER);
        launcher.launch(address(token), address(rewards), address(lock), salt);

        // 1,000 $IMD of fees reach the launch-day pot (donation + accrue stands in for harvested swap fees).
        imd.mint(address(rewards), 1_000 ether);
        rewards.accrue();

        vm.warp(20_001 days);
        uint256[] memory epochs = new uint256[](1);
        epochs[0] = 20_000;
        // The requester is the only claimable holder of the epoch; it should receive (almost) the whole pot.
        uint256 paid = rewards.claimable(REQUESTER, 20_000);
        emit log_named_uint("requester claimable (wei)", paid);
        emit log_named_uint("launcher weight (wei)", rewards.weightOf(address(launcher), 20_000));
        emit log_named_uint("eligible supply (wei)", rewards.eligibleSupplyAt(20_000));
        assertGt(paid, 990 ether, "launch-day pot diluted by the launcher's pre-launch balance");
    }
}

// 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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";

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

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

/// @dev Stands in for the factory: deploys the four manifest contracts in one call, in manifest order.
contract FactoryStandIn {
    function deployAll(address requester, IPoolManager poolManager, address imd)
        external
        returns (DeezLaunch launcher, DeezToken token, DeezRewards rewards, DeezLiquidityLock lock)
    {
        launcher = new DeezLaunch(requester, poolManager, imd);
        token = new DeezToken(address(launcher));
        rewards = new DeezRewards(address(token), imd, address(poolManager), address(launcher));
        lock = new DeezLiquidityLock(poolManager, address(rewards));
    }
}

/// @dev Minimal router: exact-input swap paid from its own balances.
contract Router is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amountSpecified) external returns (BalanceDelta) {
        uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        bytes memory out = manager.unlock(abi.encode(key, SwapParams(zeroForOne, amountSpecified, limit)));
        return abi.decode(out, (BalanceDelta));
    }

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

    function _settle(Currency currency, int128 amount) private {
        if (amount < 0) {
            uint256 owed = uint256(uint128(-amount));
            manager.sync(currency);
            IERC20(Currency.unwrap(currency)).transfer(address(manager), owed);
            manager.settle();
        } else if (amount > 0) {
            manager.take(currency, address(this), uint256(uint128(amount)));
        }
    }
}

/// @notice The factory deploys the four contracts at the start of a UTC day; the requester mines the salt and
/// launches twelve hours later, in the same epoch. All trading of the launch day happens after the launch.
/// `DeezLaunch` held the whole supply for the first half of the day and is not excluded from `eligibleSupplyAt`,
/// so it carries ~99% of the day's weight, can never claim, and the launch-day holders get ~1% of the pot.
contract LauncherWeightTest is Test {
    uint160 internal constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    address internal constant REQUESTER = address(0xB045);
    uint256 internal constant EPOCH = 1 days;

    PoolManager internal manager;
    ImdMock internal imd;
    DeezLaunch internal launcher;
    DeezToken internal token;
    DeezRewards internal rewards;
    DeezLiquidityLock internal lock;
    DeezHook internal hook;
    PoolKey internal key;
    bool internal tokenIsCurrency0;

    function setUp() public {
        uint256 epochStart = 20_000 * EPOCH; // first second of epoch 20,000
        vm.warp(epochStart);
        manager = new PoolManager(address(this));
        imd = new ImdMock();
        FactoryStandIn factory = new FactoryStandIn();
        (launcher, token, rewards, lock) = factory.deployAll(REQUESTER, IPoolManager(address(manager)), address(imd));
        tokenIsCurrency0 = address(token) < address(imd);

        // The requester launches twelve hours later, in the same epoch.
        vm.warp(epochStart + 12 hours);
        bytes32 salt;
        for (uint256 i = 0; i < 300_000; i++) {
            address predicted = launcher.hookAddress(bytes32(i), address(token), address(rewards), address(lock));
            if (uint160(predicted) & ((1 << 14) - 1) == FLAGS) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(REQUESTER);
        hook = launcher.launch(address(token), address(rewards), address(lock), salt);
        key = hook.poolKey();
    }

    function test_launchDayHoldersGetTheLaunchDayFees() public {
        uint256 epoch = rewards.currentEpoch();
        assertEq(epoch, 20_000);
        assertEq(token.balanceOf(address(launcher)), 0, "the launcher holds nothing after the launch");

        // The launch day's trading: a buyer pays 50 $IMD for $DEEZ; the hook keeps 2% = 1 $IMD for the epoch.
        Router buyer = new Router(IPoolManager(address(manager)));
        imd.mint(address(buyer), 50 ether);
        buyer.swap(key, !tokenIsCurrency0, -50 ether);
        uint256 pot = hook.pendingFeesOf(epoch);
        assertEq(pot, 1 ether);

        // The day ends. The only non-excluded $DEEZ holders of the day are the requester (10,000,000 $DEEZ for
        // the last twelve hours), the buyer (a few thousand $DEEZ for seconds) and the lock's shave dust.
        vm.warp((epoch + 1) * EPOCH);
        uint256 requesterWeight = rewards.weightOf(REQUESTER, epoch);
        uint256 buyerWeight = rewards.weightOf(address(buyer), epoch);
        uint256 lockWeight = rewards.weightOf(address(lock), epoch);
        uint256 launcherWeight = rewards.weightOf(address(launcher), epoch);
        assertEq(requesterWeight, 10_000_000 ether / 2, "ten million for half a day");
        assertEq(launcherWeight, 1_000_000_000 ether / 2, "the launcher held the whole supply for half a day");

        uint256[] memory epochs = new uint256[](1);
        epochs[0] = epoch;
        vm.prank(REQUESTER);
        uint256 paid = rewards.claim(REQUESTER, epochs);
        vm.prank(address(buyer));
        paid += rewards.claim(address(buyer), epochs);

        // Expected: the launch day's holders together receive the launch day's fees (minus the lock's dust share,
        // well under 0.1%). Actual: ~1%, the rest is attributed to the launcher, which can never claim, and is
        // only recycled into the pot of epoch 20,091 for whoever holds $DEEZ then.
        uint256 expectedFloor = pot * (requesterWeight + buyerWeight) / (requesterWeight + buyerWeight + lockWeight);
        assertGe(paid, expectedFloor - 1, "launch-day holders are paid the launch-day pot");
    }
}

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

import {Test, console} 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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";

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

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

/// @dev Stands in for the factory: deploys the four application contracts in one call, manifest order.
contract Factory {
    function deployAll(address requester, IPoolManager pm, address imd)
        external
        returns (DeezLaunch launcher, DeezToken token, DeezRewards rewards, DeezLiquidityLock lock)
    {
        launcher = new DeezLaunch(requester, pm, imd);
        token = new DeezToken(address(launcher));
        rewards = new DeezRewards(address(token), imd, address(pm), address(launcher));
        lock = new DeezLiquidityLock(pm, address(rewards));
    }
}

/// @dev Minimal router: exact-input swap paid from its own balance.
contract Buyer is IUnlockCallback {
    IPoolManager public immutable pm;

    constructor(IPoolManager pm_) {
        pm = pm_;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amountSpecified) external returns (BalanceDelta) {
        uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        return abi.decode(pm.unlock(abi.encode(key, SwapParams(zeroForOne, amountSpecified, limit))), (BalanceDelta));
    }

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

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            pm.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(pm), uint256(uint128(-amount)));
            pm.settle();
        } else if (amount > 0) {
            pm.take(c, address(this), uint256(uint128(amount)));
        }
    }
}

/// @notice The launcher holds the whole supply from the factory transaction until `launch`, and `DeezRewards`
/// does not exclude it. Its average balance over the launch day therefore dominates `eligibleSupplyAt(launchDay)`,
/// so the holders who actually traded and held on launch day can claim only a small slice of that day's fees;
/// the rest is owed to a contract that cannot claim and is only recycled 91 days later.
/// Fails on the current code (holders can claim ~4% of the launch-day pot); passes once the launcher's
/// pre-launch holding no longer counts as eligible supply (e.g. `isExcluded(launcher)`).
contract LauncherWeightTest is Test {
    address constant REQUESTER = address(0xB045);
    uint256 constant DAY = 1 days;

    PoolManager pm;
    Imd imd;
    DeezLaunch launcher;
    DeezToken token;
    DeezRewards rewards;
    DeezLiquidityLock lock;
    DeezHook hook;
    PoolKey key;
    bool tokenIsCurrency0;

    function setUp() public {
        // Factory transaction at 01:00 UTC of day E: the supply is minted to the launcher now.
        uint256 dayStart = (1_700_000_000 / DAY) * DAY;
        vm.warp(dayStart + 1 hours);
        pm = new PoolManager(address(this));
        imd = new Imd();
        Factory factory = new Factory();
        (launcher, token, rewards, lock) = factory.deployAll(REQUESTER, IPoolManager(address(pm)), address(imd));
        tokenIsCurrency0 = address(token) < address(imd);
    }

    function mineSalt() internal view returns (bytes32) {
        for (uint256 i = 0; i < 300_000; i++) {
            address predicted = launcher.hookAddress(bytes32(i), address(token), address(rewards), address(lock));
            if (uint160(predicted) & ((1 << 14) - 1) == 0x20CC) return bytes32(i);
        }
        revert("no salt");
    }

    function test_launchDayFeesAreMostlyOwedToTheLauncher() public {
        uint256 epoch = block.timestamp / DAY;
        // The requester launches at 12:00 UTC of the same day: the launcher held 1,000,000,000 $DEEZ for 11 hours.
        vm.warp(epoch * DAY + 12 hours);
        bytes32 salt = mineSalt();
        vm.prank(REQUESTER);
        hook = launcher.launch(address(token), address(rewards), address(lock), salt);
        key = hook.poolKey();

        // A buyer pays 100 $IMD for $DEEZ right after launch: 2 $IMD of fees are recorded against the launch day.
        Buyer buyer = new Buyer(IPoolManager(address(pm)));
        imd.mint(address(buyer), 100 ether);
        buyer.swap(key, !tokenIsCurrency0, -100 ether);
        assertEq(hook.pendingFeesOf(epoch), 2 ether);

        // The day ends; anyone harvests. The launch-day pot is 2 $IMD.
        vm.warp((epoch + 1) * DAY + 1);
        hook.harvest();
        (uint128 pot,,,) = rewards.pots(epoch);
        assertEq(pot, 2 ether);

        // Everyone who is not excluded and holds $DEEZ after launch: the requester (10,000,000), the buyer and the
        // lock's 1 ppm dust. Together they should be able to claim (almost) the whole pot of the day they traded.
        uint256 claimableByHolders = rewards.claimable(REQUESTER, epoch) + rewards.claimable(address(buyer), epoch)
            + rewards.claimable(address(lock), epoch);
        uint256 launcherWeight = rewards.weightOf(address(launcher), epoch);
        console.log("eligible supply (wei-days):", rewards.eligibleSupplyAt(epoch));
        console.log("launcher weight  (wei-days):", launcherWeight);
        console.log("pot (wei):", pot);
        console.log("claimable by live holders (wei):", claimableByHolders);
        assertEq(token.balanceOf(address(launcher)), 0, "the launcher holds nothing after launch");
        // The launcher cannot claim: `claim` requires msg.sender == account and the launcher has no such call.
        assertGe(claimableByHolders, uint256(pot) * 99 / 100, "launch-day holders can claim the launch-day fees");
    }
}

// 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 {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 {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";
import {HookFlags} from "src/HookFlags.sol";

contract PairToken is ERC20 {
    constructor() ERC20("IMD", "IMD") {}
    function mint(address to, uint256 a) external { _mint(to, a); }
}

contract Buyer is IUnlockCallback {
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    function swap(PoolKey memory key, bool zeroForOne, int256 amt) external {
        m.unlock(abi.encode(key, zeroForOne, amt));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (PoolKey memory key, bool z, int256 amt) = abi.decode(data, (PoolKey, bool, int256));
        uint160 limit = z ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        BalanceDelta d = m.swap(key, SwapParams(z, amt, limit), "");
        _s(key.currency0, d.amount0());
        _s(key.currency1, d.amount1());
        return "";
    }
    function _s(Currency c, int128 a) private {
        if (a < 0) { m.sync(c); IERC20(Currency.unwrap(c)).transfer(address(m), uint256(uint128(-a))); m.settle(); }
        else if (a > 0) m.take(c, address(this), uint256(uint128(a)));
    }
}

contract Factory {
    function deployAll(address req, IPoolManager pm, address imd)
        external returns (DeezLaunch l, DeezToken t, DeezRewards r, DeezLiquidityLock k)
    {
        l = new DeezLaunch(req, pm, imd);
        t = new DeezToken(address(l));
        r = new DeezRewards(address(t), imd, address(pm), address(l));
        k = new DeezLiquidityLock(pm, address(r));
    }
}

/// The launcher holds the whole supply from factory deployment until `launch`, is not excluded from rewards and
/// cannot claim, so it takes most of the launch epoch's fees away from the real holders of that epoch.
contract LauncherWeightTest is Test {
    uint160 constant FLAGS = HookFlags.BEFORE_INITIALIZE | HookFlags.BEFORE_SWAP | HookFlags.AFTER_SWAP
        | HookFlags.BEFORE_SWAP_RETURN_DELTA | HookFlags.AFTER_SWAP_RETURN_DELTA;
    address constant REQ = address(0xB045);

    function test_launchEpochFeesReachTheHoldersOfTheLaunchEpoch() public {
        uint256 E = 20_000;
        vm.warp(E * 1 days); // factory deploys at the start of epoch E
        PoolManager manager = new PoolManager(address(this));
        PairToken imd = new PairToken();
        (DeezLaunch launcher, DeezToken token, DeezRewards rewards, DeezLiquidityLock lock) =
            new Factory().deployAll(REQ, IPoolManager(address(manager)), address(imd));

        vm.warp(E * 1 days + 6 hours); // the requester launches six hours later
        bytes32 salt;
        for (uint256 i = 0; i < 300_000; i++) {
            if (HookFlags.matches(launcher.hookAddress(bytes32(i), address(token), address(rewards), address(lock)), FLAGS)) {
                salt = bytes32(i);
                break;
            }
        }
        vm.prank(REQ);
        DeezHook hook = launcher.launch(address(token), address(rewards), address(lock), salt);

        bool t0 = address(token) < address(imd);
        PoolKey memory key = PoolKey(
            t0 ? Currency.wrap(address(token)) : Currency.wrap(address(imd)),
            t0 ? Currency.wrap(address(imd)) : Currency.wrap(address(token)),
            12_500, 60, IHooks(address(hook))
        );
        Buyer buyer = new Buyer(IPoolManager(address(manager)));
        imd.mint(address(buyer), 1_000 ether);
        buyer.swap(key, !t0, -1_000 ether); // a buy: 20 $IMD fee in epoch E

        vm.warp((E + 1) * 1 days);
        uint256 potTotal = hook.pendingFeesOf(E);
        assertEq(potTotal, 20 ether);
        uint256 toHolders = rewards.claimable(REQ, E) + rewards.claimable(address(buyer), E);
        uint256 toLauncher = rewards.claimable(address(launcher), E);
        emit log_named_uint("to holders", toHolders);
        emit log_named_uint("to launcher (unclaimable)", toLauncher);
        // Every wei of the launch epoch's fee should be claimable by the accounts that can claim it.
        assertGe(toHolders, potTotal * 99 / 100, "launch-epoch fees diverted to the launcher's weight");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract AtomicityPair is ERC20 {
    constructor() ERC20("Test IMD", "IMD") {}
}

contract AtomicityDeploymentFactory {
    function deployAll(address requester, IPoolManager manager, address pair)
        external returns (DeezLaunch launch, DeezToken token, DeezRewards rewards, DeezLiquidityLock liquidityLock)
    {
        launch = new DeezLaunch(requester, manager, pair);
        token = new DeezToken(address(launch));
        rewards = new DeezRewards(address(token), pair, address(manager), address(launch));
        liquidityLock = new DeezLiquidityLock(manager, address(rewards));
    }
}

contract DeploymentAtomicityProof is Test {
    function test_deploymentMustAlreadyCustodyTheRequesterAllocationInTheLock() public {
        address requester = makeAddr("requester");
        PoolManager manager = new PoolManager(address(this));
        AtomicityPair pair = new AtomicityPair();
        AtomicityDeploymentFactory factory = new AtomicityDeploymentFactory();
        // Exactly one call for the full application-deployment transaction. No transient-state assumptions
        // and no later call impersonating the requester to complete deployment.
        (DeezLaunch launch, DeezToken token,, DeezLiquidityLock liquidityLock) =
            factory.deployAll(requester, IPoolManager(address(manager)), address(pair));
        uint256 lockedPrincipal = address(token) < address(pair)
            ? liquidityLock.totalLocked0() : liquidityLock.totalLocked1();
        // Includes rounding dust still held by the lock: the requirement fails even under this weaker bound.
        assertGe(
            lockedPrincipal + token.balanceOf(address(liquidityLock)),
            launch.LOCKED_REQUESTER_SHARE(),
            "deployment left the requester's locked allocation outside DeezLiquidityLock"
        );
        assertEq(token.balanceOf(requester), launch.PAID_REQUESTER_SHARE());
        assertTrue(launch.launched());
    }
}

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

import {Test, console} 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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezHook} from "src/DeezHook.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";

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

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

/// @dev Stands in for the factory: deploys the four application contracts in one call, manifest order.
contract Factory {
    function deployAll(address requester, IPoolManager pm, address imd)
        external
        returns (DeezLaunch launcher, DeezToken token, DeezRewards rewards, DeezLiquidityLock lock)
    {
        launcher = new DeezLaunch(requester, pm, imd);
        token = new DeezToken(address(launcher));
        rewards = new DeezRewards(address(token), imd, address(pm), address(launcher));
        lock = new DeezLiquidityLock(pm, address(rewards));
    }
}

/// @dev Minimal router: exact-input swap paid from its own balance.
contract Buyer is IUnlockCallback {
    IPoolManager public immutable pm;

    constructor(IPoolManager pm_) {
        pm = pm_;
    }

    function swap(PoolKey memory key, bool zeroForOne, int256 amountSpecified) external returns (BalanceDelta) {
        uint160 limit = zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
        return abi.decode(pm.unlock(abi.encode(key, SwapParams(zeroForOne, amountSpecified, limit))), (BalanceDelta));
    }

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

    function _settle(Currency c, int128 amount) private {
        if (amount < 0) {
            pm.sync(c);
            IERC20(Currency.unwrap(c)).transfer(address(pm), uint256(uint128(-amount)));
            pm.settle();
        } else if (amount > 0) {
            pm.take(c, address(this), uint256(uint128(amount)));
        }
    }
}

/// @notice The launcher holds the whole supply from the factory transaction until `launch`, and `DeezRewards`
/// does not exclude it. Its average balance over the launch day therefore dominates `eligibleSupplyAt(launchDay)`,
/// so the holders who actually traded and held on launch day can claim only a small slice of that day's fees;
/// the rest is owed to a contract that cannot claim and is only recycled 91 days later.
/// Fails on the current code (holders can claim ~4% of the launch-day pot); passes once the launcher's
/// pre-launch holding no longer counts as eligible supply (e.g. `isExcluded(launcher)`).
contract LauncherWeightTest is Test {
    address constant REQUESTER = address(0xB045);
    uint256 constant DAY = 1 days;

    PoolManager pm;
    Imd imd;
    DeezLaunch launcher;
    DeezToken token;
    DeezRewards rewards;
    DeezLiquidityLock lock;
    DeezHook hook;
    PoolKey key;
    bool tokenIsCurrency0;

    function setUp() public {
        // Factory transaction at 01:00 UTC of day E: the supply is minted to the launcher now.
        uint256 dayStart = (1_700_000_000 / DAY) * DAY;
        vm.warp(dayStart + 1 hours);
        pm = new PoolManager(address(this));
        imd = new Imd();
        Factory factory = new Factory();
        (launcher, token, rewards, lock) = factory.deployAll(REQUESTER, IPoolManager(address(pm)), address(imd));
        tokenIsCurrency0 = address(token) < address(imd);
    }

    function mineSalt() internal view returns (bytes32) {
        for (uint256 i = 0; i < 300_000; i++) {
            address predicted = launcher.hookAddress(bytes32(i), address(token), address(rewards), address(lock));
            if (uint160(predicted) & ((1 << 14) - 1) == 0x20CC) return bytes32(i);
        }
        revert("no salt");
    }

    function test_launchDayFeesAreMostlyOwedToTheLauncher() public {
        uint256 epoch = block.timestamp / DAY;
        // The requester launches at 12:00 UTC of the same day: the launcher held 1,000,000,000 $DEEZ for 11 hours.
        vm.warp(epoch * DAY + 12 hours);
        bytes32 salt = mineSalt();
        vm.prank(REQUESTER);
        hook = launcher.launch(address(token), address(rewards), address(lock), salt);
        key = hook.poolKey();

        // A buyer pays 100 $IMD for $DEEZ right after launch: 2 $IMD of fees are recorded against the launch day.
        Buyer buyer = new Buyer(IPoolManager(address(pm)));
        imd.mint(address(buyer), 100 ether);
        buyer.swap(key, !tokenIsCurrency0, -100 ether);
        assertEq(hook.pendingFeesOf(epoch), 2 ether);

        // The day ends; anyone harvests. The launch-day pot is 2 $IMD.
        vm.warp((epoch + 1) * DAY + 1);
        hook.harvest();
        (uint128 pot,,,) = rewards.pots(epoch);
        assertEq(pot, 2 ether);

        // Everyone who is not excluded and holds $DEEZ after launch: the requester (10,000,000), the buyer and the
        // lock's 1 ppm dust. Together they should be able to claim (almost) the whole pot of the day they traded.
        uint256 claimableByHolders = rewards.claimable(REQUESTER, epoch) + rewards.claimable(address(buyer), epoch)
            + rewards.claimable(address(lock), epoch);
        uint256 launcherWeight = rewards.weightOf(address(launcher), epoch);
        console.log("eligible supply (wei-days):", rewards.eligibleSupplyAt(epoch));
        console.log("launcher weight  (wei-days):", launcherWeight);
        console.log("pot (wei):", pot);
        console.log("claimable by live holders (wei):", claimableByHolders);
        assertEq(token.balanceOf(address(launcher)), 0, "the launcher holds nothing after launch");
        // The launcher cannot claim: `claim` requires msg.sender == account and the launcher has no such call.
        assertGe(claimableByHolders, uint256(pot) * 99 / 100, "launch-day holders can claim the launch-day fees");
    }
}

// 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 {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {DeezLaunch} from "src/DeezLaunch.sol";
import {DeezToken} from "src/DeezToken.sol";
import {DeezRewards} from "src/DeezRewards.sol";
import {DeezLiquidityLock} from "src/DeezLiquidityLock.sol";

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

/// @notice The launch factory deploys the manifest's contracts in one transaction: one call here.
contract OneTransactionDeployment {
    function deploy(address requester, IPoolManager manager, address imd)
        external
        returns (DeezLaunch launcher, DeezToken token, DeezRewards rewards, DeezLiquidityLock lock)
    {
        launcher = new DeezLaunch(requester, manager, imd);
        token = new DeezToken(address(launcher));
        rewards = new DeezRewards(address(token), imd, address(manager), address(launcher));
        lock = new DeezLiquidityLock(manager, address(rewards));
    }
}

/// The brief: at least 10,000,000 $DEEZ of the requester's 2% is sent to DeezLiquidityLock and locked in the
/// same transaction as deployment. After the deployment transaction nothing is locked: the allocation is still
/// in DeezLaunch and only a later, requester-only `launch` call (which the requester may never send) locks it.
contract DeploymentLocksRequesterShareProof is Test {
    function test_deploymentTransactionLocksAtLeastTenMillionOfTheRequesterShare() public {
        PoolManager manager = new PoolManager(address(this));
        PairToken imd = new PairToken();
        OneTransactionDeployment factory = new OneTransactionDeployment();
        (DeezLaunch launcher, DeezToken token,, DeezLiquidityLock lock) =
            factory.deploy(makeAddr("requester"), IPoolManager(address(manager)), address(imd));

        // Locked = moved into the PoolManager as the lock's permanent position (the lock only ever adds).
        uint256 lockedDeez = token.balanceOf(address(manager));
        assertGe(lockedDeez, 10_000_000 ether, "requester share locked in the deployment transaction");
        assertGe(lock.totalLocked0() + lock.totalLocked1(), 10_000_000 ether, "lock recorded the locked share");
        assertTrue(launcher.launched(), "deployment left the launch unfinished");
    }
}