// 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 {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 {MediciToken} from "src/MediciToken.sol";
import {MediciTreasury} from "src/MediciTreasury.sol";
import {Protocol, IIntake, IMediciHook} from "src/Protocol.sol";

contract CollisionMockToken is ERC20 {
    constructor() ERC20("Launch asset", "ASSET") {}

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

/// @dev Stands in for either factory. Each factory instance keeps its own numbering.
contract CollisionMockFactory {
    struct Position {
        PoolKey key;
        int24 lower;
        int24 upper;
        address requester;
    }
    mapping(uint64 => Position) private positions;
    mapping(uint64 => uint256) public pending1;

    function register(uint64 n, PoolKey memory key, address requester) external {
        positions[n] = Position(key, -60, 60, requester);
    }

    function positionOf(uint64 n) external view returns (PoolKey memory, int24, int24, address) {
        Position storage p = positions[n];
        return (p.key, p.lower, p.upper, p.requester);
    }

    function claimFees(uint64 n) external returns (uint256 a0, uint256 a1) {
        Position storage p = positions[n];
        require(p.requester != address(0));
        a1 = pending1[n];
        delete pending1[n];
        if (a1 != 0) require(IERC20(Currency.unwrap(p.key.currency1)).transfer(p.requester, a1));
    }

    function withdraw(address, Currency) external {}
    receive() external payable {}
}

contract CollisionMockIntake is IIntake {
    uint256 public nonce;

    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

contract CollisionMockHook is IMediciHook {
    uint64 public openedAt;
    uint256 public price = 1e10;

    constructor(uint64 at) {
        openedAt = at;
    }

    function twap(uint64, uint64) external view returns (uint256) {
        return price;
    }

    function poolKey() external pure returns (PoolKey memory) {
        revert();
    }
}

/// @notice Two different launches, one per factory, that happen to carry the same launch number.
/// The treasury keys recorded launches by number alone, so the second one can never be recorded,
/// its backers never get a share, its proposer never gets the bounty, and the launch tokens the
/// treasury already holds for it can never be claimed, burned or harvested.
contract LaunchNumberCollisionTest is Test {
    MediciToken token;
    MediciTreasury treasury;
    CollisionMockHook oracle;
    CollisionMockFactory launchFactory;
    CollisionMockFactory projectFactory;
    CollisionMockToken imd;
    address alice = address(0xA11CE);
    uint64 constant OPEN = 1_800_000_000;

    function setUp() public {
        vm.warp(OPEN);
        vm.deal(address(this), 100 ether);
        token = new MediciToken();
        oracle = new CollisionMockHook(OPEN);
        treasury = new MediciTreasury(IPoolManager(address(this)), address(token), IMediciHook(address(oracle)));
        token.transfer(alice, 300_000_000 ether);
        vm.prank(alice);
        token.approve(address(treasury), type(uint256).max);

        CollisionMockFactory f = new CollisionMockFactory();
        vm.etch(Protocol.LAUNCH_FACTORY, address(f).code);
        vm.etch(Protocol.PROJECT_FACTORY, address(f).code);
        launchFactory = CollisionMockFactory(payable(Protocol.LAUNCH_FACTORY));
        projectFactory = CollisionMockFactory(payable(Protocol.PROJECT_FACTORY));
        CollisionMockIntake i = new CollisionMockIntake();
        vm.etch(Protocol.INTAKE, address(i).code);
        CollisionMockToken t = new CollisionMockToken();
        vm.etch(Protocol.IMD, address(t).code);
        imd = CollisionMockToken(Protocol.IMD);
    }

    function _winEpoch(uint256 e, bytes memory brief) internal {
        vm.prank(alice);
        uint256 id = treasury.propose("A commissioned launch", brief);
        vm.prank(alice);
        treasury.vote(e, id, 3_000_000 ether);
        (bool ok,) = address(treasury).call{value: 1 ether}("");
        require(ok);
        vm.warp(treasury.epochEnd(e));
        treasury.settle(e);
        imd.mint(address(treasury), 0.5 ether);
        vm.prank(Protocol.KEEPER);
        treasury.commission(e, brief);
    }

    function _position(CollisionMockFactory f, uint64 n, CollisionMockToken asset) internal {
        PoolKey memory k =
            PoolKey(Currency.wrap(address(0)), Currency.wrap(address(asset)), 12_500, 60, IHooks(address(0)));
        f.register(n, k, address(treasury));
        asset.mint(address(this), 950 ether);
        asset.mint(address(treasury), 50 ether);
    }

    function test_sameLaunchNumberOnTheOtherFactoryCanStillBeRecorded() public {
        // Epoch 1: a hook launch, number 77 on LaunchFactory, is recorded.
        _winEpoch(1, bytes("{\"idea\":\"one\"}"));
        CollisionMockToken assetA = new CollisionMockToken();
        _position(launchFactory, 77, assetA);
        vm.prank(Protocol.KEEPER);
        treasury.recordCommission(1, 77, "job-1");
        (uint8 status,,,,,,) = treasury.epochResult(1);
        assertEq(status, 2);

        // Epoch 2: a project launch, number 77 on ProjectFactory. The treasury is its requester
        // and holds 5% of its supply, exactly what recordCommission demands.
        vm.warp(treasury.epochEnd(1) + 1);
        _winEpoch(2, bytes("{\"idea\":\"two\"}"));
        CollisionMockToken assetB = new CollisionMockToken();
        _position(projectFactory, 77, assetB);
        vm.prank(Protocol.KEEPER);
        treasury.recordCommission(2, 77, "job-2");

        (status,,,,,,) = treasury.epochResult(2);
        assertEq(status, 2, "the second launch is recordable");
        assertEq(treasury.claimable(2, alice), 50 ether, "its backers can claim their share");
    }
}

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

import {Test} from "forge-std/Test.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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {MediciToken} from "src/MediciToken.sol";
import {MediciHook} from "src/MediciHook.sol";
import {HookFlags} from "src/HookFlags.sol";

contract ProofActor {
    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function modify(PoolKey memory k, int24 lower, int24 upper, int256 liquidity) external {
        manager.unlock(abi.encode(uint8(0), k, abi.encode(ModifyLiquidityParams(lower, upper, liquidity, 0))));
    }

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

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

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

    receive() external payable {}
}

/// @notice During the 15-minute buy-fee decay, exact-input ETH buys of ordinary amounts revert in
/// afterSwap with InvalidQuote because beforeSwap's budget-derived fee can exceed
/// `ethBase * rate / 10_000` by two wei while afterSwap tolerates only one.
contract FeeRoundingProofTest is Test {
    PoolManager manager;
    MediciToken token;
    MediciHook hook;
    PoolKey key;
    ProofActor actor;
    uint64 constant OPEN = 1_800_000_000;
    uint160 constant Q96 = 79228162514264337593543950336;

    function setUp() public {
        vm.warp(OPEN);
        vm.deal(address(this), 1_000 ether);
        manager = new PoolManager(address(this));
        token = new MediciToken();
        bytes memory code = abi.encodePacked(type(MediciHook).creationCode, abi.encode(manager, address(token)));
        bytes32 hash = keccak256(code);
        address at;
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(predicted, HookFlags.MEDICI)) continue;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            break;
        }
        require(at != address(0), "hook deployment failed");
        hook = MediciHook(payable(at));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(at));
        manager.initialize(key, Q96 * 10_000);
        actor = new ProofActor(manager);
        vm.deal(address(actor), 100 ether);
        token.transfer(address(actor), 600_000_000 ether);
        actor.modify(key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e22);
    }

    /// 60 seconds after opening the buy rate is 4680 bps. For an exact input of
    /// 1_000_000_000_000_000_001 wei: target = 681_198_910_081_743_869, fee = 318_801_089_918_256_132,
    /// but afterSwap's exact = 318_801_089_918_256_130, so fee == exact + 2 and the swap reverts.
    function test_exactInputBuyRevertsDuringDecay() public {
        vm.warp(OPEN + 60);
        assertEq(hook.buyFeeBps(), 4680);
        int256 amount = -int256(1_000_000_000_000_000_001);
        // Expected: the buy goes through (an exact-input buy is an ordinary trade).
        actor.swap(key, true, amount, TickMath.MIN_SQRT_PRICE + 1);
        assertGt(hook.treasuryOwed() + address(hook.treasury()).balance + hook.teamOwed(), 0);
    }

    /// Many consecutive amounts fail, not a single unlucky wei: out of 40 consecutive inputs around
    /// 0.5 ETH at the same instant, at least 8 revert.
    function test_manyAmountsRevertDuringDecay() public {
        vm.warp(OPEN + 60);
        uint256 reverted;
        for (uint256 i; i < 40; ++i) {
            uint256 snap = vm.snapshotState();
            try actor.swap(key, true, -int256(0.5 ether + i), TickMath.MIN_SQRT_PRICE + 1) {}
            catch {
                ++reverted;
            }
            vm.revertToState(snap);
        }
        assertEq(reverted, 0, "exact-input buys revert during the decay window");
    }
}

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

import {Test} from "forge-std/Test.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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {MediciToken} from "src/MediciToken.sol";
import {MediciHook} from "src/MediciHook.sol";
import {HookFlags} from "src/HookFlags.sol";

contract Swapper {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function modify(PoolKey memory k, int24 lower, int24 upper, int256 liquidity) external returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(0), k, abi.encode(ModifyLiquidityParams(lower, upper, liquidity, 0)))),
            (BalanceDelta)
        );
    }

    function swap(PoolKey memory k, bool zeroForOne, int256 amount, uint160 limit) external returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(1), k, abi.encode(SwapParams(zeroForOne, amount, limit)))), (BalanceDelta)
        );
    }

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

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

    receive() external payable {}
}

/// @notice During the 15-minute buy-fee decay, beforeSwap's exact-in fee (specified - floor(specified*10000/(10000+rate)))
/// can exceed afterSwap's recomputed bound floor(target*rate/10000) + 1 by one more wei, so the swap reverts InvalidQuote.
contract BuyDecayRoundingTest is Test {
    uint64 internal constant OPEN = 1_800_000_000;
    uint160 internal constant Q96 = 79228162514264337593543950336;
    PoolManager internal manager;
    MediciToken internal token;
    MediciHook internal hook;
    PoolKey internal key;
    Swapper internal actor;

    function setUp() public {
        vm.warp(OPEN);
        vm.deal(address(this), 1_000 ether);
        manager = new PoolManager(address(this));
        token = new MediciToken();
        bytes memory code = abi.encodePacked(type(MediciHook).creationCode, abi.encode(manager, address(token)));
        bytes32 hash = keccak256(code);
        address at;
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(predicted, HookFlags.MEDICI)) continue;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            break;
        }
        require(at != address(0), "hook deployment failed");
        hook = MediciHook(payable(at));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(at));
        manager.initialize(key, Q96 * 10_000);
        actor = new Swapper(manager);
        vm.deal(address(actor), 100 ether);
        token.transfer(address(actor), 600_000_000 ether);
        actor.modify(key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e22);
    }

    /// Two seconds after open the buy rate is 4989 bps. For specified = 1 ether + 1 wei:
    /// target = floor(specified * 10000 / 14989) = 667155914337180599, fee = specified - target = 332844085662819402,
    /// but afterSwap recomputes exact = target * 4989 / 10000 = 332844085662819400 and requires fee <= exact + 1.
    /// About a third of all exact-in buy amounts hit this during the decay window (whenever specified*10000 mod 14989 > 10000).
    function test_exactInBuyDuringDecayDoesNotRevertOnTwoWeiRoundingGap() public {
        vm.warp(OPEN + 2);
        assertEq(hook.buyFeeBps(), 4989);
        // Control: an amount whose remainder is below 10000 settles fine.
        BalanceDelta ok = actor.swap(key, true, -int256(1 ether), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(ok.amount0(), -int128(int256(1 ether)));
        // One wei more must be a valid buy as well; today it reverts with InvalidQuote inside afterSwap.
        uint256 specified = 1 ether + 1;
        BalanceDelta d = actor.swap(key, true, -int256(specified), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(d.amount0(), -int128(int256(specified)));
        assertGt(d.amount1(), 0);
    }
}

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

import {Test} from "forge-std/Test.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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {MediciToken} from "src/MediciToken.sol";
import {MediciHook} from "src/MediciHook.sol";
import {HookFlags} from "src/HookFlags.sol";

contract Swapper {
    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function modify(PoolKey memory k, int24 lower, int24 upper, int256 liquidity) external returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(0), k, abi.encode(ModifyLiquidityParams(lower, upper, liquidity, 0)))),
            (BalanceDelta)
        );
    }

    function swap(PoolKey memory k, bool zeroForOne, int256 amount, uint160 limit) external returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(1), k, abi.encode(SwapParams(zeroForOne, amount, limit)))), (BalanceDelta)
        );
    }

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

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

    receive() external payable {}
}

/// @notice Exact-in ETH buys during the launch decay revert in afterSwap because the
/// specified-side fee computed in beforeSwap (specified - target) can exceed
/// floor(target * rate / 10_000) by two wei, while afterSwap allows at most one.
contract FeeBoundTest is Test {
    PoolManager internal manager;
    MediciToken internal token;
    MediciHook internal hook;
    PoolKey internal key;
    Swapper internal actor;
    uint64 internal constant OPEN = 1_800_000_000;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    function setUp() public {
        vm.warp(OPEN);
        vm.deal(address(this), 1_000 ether);
        manager = new PoolManager(address(this));
        token = new MediciToken();
        bytes memory code = abi.encodePacked(type(MediciHook).creationCode, abi.encode(manager, address(token)));
        bytes32 hash = keccak256(code);
        address at;
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(predicted, HookFlags.MEDICI)) continue;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            break;
        }
        require(at != address(0), "CREATE2 mining/deployment failed");
        hook = MediciHook(payable(at));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(at));
        manager.initialize(key, Q96 * 10_000);
        actor = new Swapper(manager);
        vm.deal(address(actor), 100 ether);
        token.transfer(address(actor), 600_000_000 ether);
        actor.modify(key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e22);
    }

    /// 60 seconds after open the buy rate is 4680 bps. For a 0.01 ETH exact-in buy:
    /// target = 1e16 * 10000 / 14680 = 6811989100817438, fee = 3188010899182562,
    /// but floor(target * 4680 / 10000) = 3188010899182560, so fee == exact + 2 and
    /// afterSwap reverts with InvalidQuote. The trade itself is perfectly valid.
    function test_exactInBuyOfRoundAmountDuringDecayMustNotRevert() public {
        vm.warp(OPEN + 60);
        assertEq(hook.buyFeeBps(), 4680);
        uint256 amount = 0.01 ether;
        uint256 target = amount * 10_000 / (10_000 + 4680);
        assertEq(amount - target, target * 4680 / 10_000 + 2, "fee is two wei above the rounded-down rate");
        BalanceDelta d = actor.swap(key, true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(d.amount0(), -int128(int256(amount)), "the swapper pays exactly the specified ETH");
        assertGt(d.amount1(), 0, "and receives MEDICI");
        assertEq(hook.teamOwed(), target * 50 / 10_000, "team share accrued on the pool ETH delta");
    }

    /// The same bound is reached at many other decay rates; one second after open (4994 bps)
    /// with 0.01 ETH + 2 wei.
    function test_exactInBuyOneSecondAfterOpen() public {
        vm.warp(OPEN + 1);
        assertEq(hook.buyFeeBps(), 4994);
        uint256 amount = 10000000000000002;
        BalanceDelta d = actor.swap(key, true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(d.amount0(), -int128(int256(amount)));
        assertGt(d.amount1(), 0);
    }
}

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

import {Test} from "forge-std/Test.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 {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {MediciToken} from "src/MediciToken.sol";
import {MediciHook} from "src/MediciHook.sol";
import {HookFlags} from "src/HookFlags.sol";

contract Swapper {
    IPoolManager public immutable manager;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function modify(PoolKey memory k, int24 lower, int24 upper, int256 liquidity) external returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(0), k, abi.encode(ModifyLiquidityParams(lower, upper, liquidity, 0)))),
            (BalanceDelta)
        );
    }

    function swap(PoolKey memory k, bool zeroForOne, int256 amount, uint160 limit) external returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(uint8(1), k, abi.encode(SwapParams(zeroForOne, amount, limit)))), (BalanceDelta)
        );
    }

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

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

    receive() external payable {}
}

/// @notice Exact-in ETH buys during the launch decay revert in afterSwap because the
/// specified-side fee computed in beforeSwap (specified - target) can exceed
/// floor(target * rate / 10_000) by two wei, while afterSwap allows at most one.
contract FeeBoundTest is Test {
    PoolManager internal manager;
    MediciToken internal token;
    MediciHook internal hook;
    PoolKey internal key;
    Swapper internal actor;
    uint64 internal constant OPEN = 1_800_000_000;
    uint160 internal constant Q96 = 79228162514264337593543950336;

    function setUp() public {
        vm.warp(OPEN);
        vm.deal(address(this), 1_000 ether);
        manager = new PoolManager(address(this));
        token = new MediciToken();
        bytes memory code = abi.encodePacked(type(MediciHook).creationCode, abi.encode(manager, address(token)));
        bytes32 hash = keccak256(code);
        address at;
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (!HookFlags.matches(predicted, HookFlags.MEDICI)) continue;
            assembly ("memory-safe") {
                at := create2(0, add(code, 32), mload(code), salt)
            }
            break;
        }
        require(at != address(0), "CREATE2 mining/deployment failed");
        hook = MediciHook(payable(at));
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12_500, 60, IHooks(at));
        manager.initialize(key, Q96 * 10_000);
        actor = new Swapper(manager);
        vm.deal(address(actor), 100 ether);
        token.transfer(address(actor), 600_000_000 ether);
        actor.modify(key, TickMath.minUsableTick(60), TickMath.maxUsableTick(60), 1e22);
    }

    /// 60 seconds after open the buy rate is 4680 bps. For a 0.01 ETH exact-in buy:
    /// target = 1e16 * 10000 / 14680 = 6811989100817438, fee = 3188010899182562,
    /// but floor(target * 4680 / 10000) = 3188010899182560, so fee == exact + 2 and
    /// afterSwap reverts with InvalidQuote. The trade itself is perfectly valid.
    function test_exactInBuyOfRoundAmountDuringDecayMustNotRevert() public {
        vm.warp(OPEN + 60);
        assertEq(hook.buyFeeBps(), 4680);
        uint256 amount = 0.01 ether;
        uint256 target = amount * 10_000 / (10_000 + 4680);
        assertEq(amount - target, target * 4680 / 10_000 + 2, "fee is two wei above the rounded-down rate");
        BalanceDelta d = actor.swap(key, true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(d.amount0(), -int128(int256(amount)), "the swapper pays exactly the specified ETH");
        assertGt(d.amount1(), 0, "and receives MEDICI");
        assertEq(hook.teamOwed(), target * 50 / 10_000, "team share accrued on the pool ETH delta");
    }

    /// The same bound is reached at many other decay rates; one second after open (4994 bps)
    /// with 0.01 ETH + 2 wei.
    function test_exactInBuyOneSecondAfterOpen() public {
        vm.warp(OPEN + 1);
        assertEq(hook.buyFeeBps(), 4994);
        uint256 amount = 10000000000000002;
        BalanceDelta d = actor.swap(key, true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1);
        assertEq(d.amount0(), -int128(int256(amount)));
        assertGt(d.amount1(), 0);
    }
}

// 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 {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 {MediciToken} from "src/MediciToken.sol";
import {MediciTreasury} from "src/MediciTreasury.sol";
import {Protocol, IIntake, IMediciHook} from "src/Protocol.sol";

contract CollisionMockToken is ERC20 {
    constructor() ERC20("Launch asset", "ASSET") {}

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

/// @dev Stands in for either factory. Each factory instance keeps its own numbering.
contract CollisionMockFactory {
    struct Position {
        PoolKey key;
        int24 lower;
        int24 upper;
        address requester;
    }
    mapping(uint64 => Position) private positions;
    mapping(uint64 => uint256) public pending1;

    function register(uint64 n, PoolKey memory key, address requester) external {
        positions[n] = Position(key, -60, 60, requester);
    }

    function positionOf(uint64 n) external view returns (PoolKey memory, int24, int24, address) {
        Position storage p = positions[n];
        return (p.key, p.lower, p.upper, p.requester);
    }

    function claimFees(uint64 n) external returns (uint256 a0, uint256 a1) {
        Position storage p = positions[n];
        require(p.requester != address(0));
        a1 = pending1[n];
        delete pending1[n];
        if (a1 != 0) require(IERC20(Currency.unwrap(p.key.currency1)).transfer(p.requester, a1));
    }

    function withdraw(address, Currency) external {}
    receive() external payable {}
}

contract CollisionMockIntake is IIntake {
    uint256 public nonce;

    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external
        payable
        returns (bytes32 id)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        id = keccak256(abi.encode(msg.sender, ++nonce));
    }
}

contract CollisionMockHook is IMediciHook {
    uint64 public openedAt;
    uint256 public price = 1e10;

    constructor(uint64 at) {
        openedAt = at;
    }

    function twap(uint64, uint64) external view returns (uint256) {
        return price;
    }

    function poolKey() external pure returns (PoolKey memory) {
        revert();
    }
}

/// @notice Two different launches, one per factory, that happen to carry the same launch number.
/// The treasury keys recorded launches by number alone, so the second one can never be recorded,
/// its backers never get a share, its proposer never gets the bounty, and the launch tokens the
/// treasury already holds for it can never be claimed, burned or harvested.
contract LaunchNumberCollisionTest is Test {
    MediciToken token;
    MediciTreasury treasury;
    CollisionMockHook oracle;
    CollisionMockFactory launchFactory;
    CollisionMockFactory projectFactory;
    CollisionMockToken imd;
    address alice = address(0xA11CE);
    uint64 constant OPEN = 1_800_000_000;

    function setUp() public {
        vm.warp(OPEN);
        vm.deal(address(this), 100 ether);
        token = new MediciToken();
        oracle = new CollisionMockHook(OPEN);
        treasury = new MediciTreasury(IPoolManager(address(this)), address(token), IMediciHook(address(oracle)));
        token.transfer(alice, 300_000_000 ether);
        vm.prank(alice);
        token.approve(address(treasury), type(uint256).max);

        CollisionMockFactory f = new CollisionMockFactory();
        vm.etch(Protocol.LAUNCH_FACTORY, address(f).code);
        vm.etch(Protocol.PROJECT_FACTORY, address(f).code);
        launchFactory = CollisionMockFactory(payable(Protocol.LAUNCH_FACTORY));
        projectFactory = CollisionMockFactory(payable(Protocol.PROJECT_FACTORY));
        CollisionMockIntake i = new CollisionMockIntake();
        vm.etch(Protocol.INTAKE, address(i).code);
        CollisionMockToken t = new CollisionMockToken();
        vm.etch(Protocol.IMD, address(t).code);
        imd = CollisionMockToken(Protocol.IMD);
    }

    function _winEpoch(uint256 e, bytes memory brief) internal {
        vm.prank(alice);
        uint256 id = treasury.propose("A commissioned launch", brief);
        vm.prank(alice);
        treasury.vote(e, id, 3_000_000 ether);
        (bool ok,) = address(treasury).call{value: 1 ether}("");
        require(ok);
        vm.warp(treasury.epochEnd(e));
        treasury.settle(e);
        imd.mint(address(treasury), 0.5 ether);
        vm.prank(Protocol.KEEPER);
        treasury.commission(e, brief);
    }

    function _position(CollisionMockFactory f, uint64 n, CollisionMockToken asset) internal {
        PoolKey memory k =
            PoolKey(Currency.wrap(address(0)), Currency.wrap(address(asset)), 12_500, 60, IHooks(address(0)));
        f.register(n, k, address(treasury));
        asset.mint(address(this), 950 ether);
        asset.mint(address(treasury), 50 ether);
    }

    function test_sameLaunchNumberOnTheOtherFactoryCanStillBeRecorded() public {
        // Epoch 1: a hook launch, number 77 on LaunchFactory, is recorded.
        _winEpoch(1, bytes("{\"idea\":\"one\"}"));
        CollisionMockToken assetA = new CollisionMockToken();
        _position(launchFactory, 77, assetA);
        vm.prank(Protocol.KEEPER);
        treasury.recordCommission(1, 77, "job-1");
        (uint8 status,,,,,,) = treasury.epochResult(1);
        assertEq(status, 2);

        // Epoch 2: a project launch, number 77 on ProjectFactory. The treasury is its requester
        // and holds 5% of its supply, exactly what recordCommission demands.
        vm.warp(treasury.epochEnd(1) + 1);
        _winEpoch(2, bytes("{\"idea\":\"two\"}"));
        CollisionMockToken assetB = new CollisionMockToken();
        _position(projectFactory, 77, assetB);
        vm.prank(Protocol.KEEPER);
        treasury.recordCommission(2, 77, "job-2");

        (status,,,,,,) = treasury.epochResult(2);
        assertEq(status, 2, "the second launch is recordable");
        assertEq(treasury.claimable(2, alice), 50 ether, "its backers can claim their share");
    }
}