// 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 {ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {MediciToken} from "src/MediciToken.sol";
import {MediciHook} from "src/MediciHook.sol";
import {MediciTreasury} from "src/MediciTreasury.sol";

/// @dev Minimal funded liquidity provider for the launch pool.
contract Seeder is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

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

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, ModifyLiquidityParams memory p) = abi.decode(data, (PoolKey, ModifyLiquidityParams));
        (BalanceDelta delta,) = manager.modifyLiquidity(key, p, "");
        if (delta.amount0() < 0) {
            manager.sync(key.currency0);
            manager.settle{value: uint256(-int256(delta.amount0()))}();
        }
        if (delta.amount1() < 0) {
            manager.sync(key.currency1);
            IERC20(Currency.unwrap(key.currency1)).transfer(address(manager), uint256(-int256(delta.amount1())));
            manager.settle();
        }
        return "";
    }

    receive() external payable {}
}

/// @notice buyback() must spend all currently unlocked ETH in one swap, bounded by a 5% min-out from the
/// TWAP. Once the unlocked amount is too large for the pool to absorb within that bound, the call reverts
/// and, because unspent ETH carries over and only grows, it reverts forever: the reserve is locked.
contract BuybackLockTest is Test {
    uint160 internal constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);
    PoolManager manager;
    MediciToken token;
    MediciHook hook;
    MediciTreasury treasury;
    PoolKey key;

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.deal(address(this), 100 ether);
        manager = new PoolManager(address(this));
        token = new MediciToken();
        hook = _deployHook();
        treasury = hook.treasury();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        // 10 ETH opening market cap for 1e9 MEDICI: sqrt(1e8) = 1e4.
        manager.initialize(key, uint160(uint256(1 << 96) * 10000));
        Seeder seeder = new Seeder(manager);
        vm.deal(address(seeder), 10 ether);
        token.transfer(address(seeder), 500_000_000 ether);
        // Full-range liquidity worth about 4 ETH on the ETH side (same depth as the project's own suite).
        seeder.modify(key, -887220, 887220, 4e22);
    }

    function _deployHook() internal returns (MediciHook h) {
        bytes memory code =
            abi.encodePacked(type(MediciHook).creationCode, abi.encode(manager, address(token), address(this), uint64(1)));
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address at = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (uint160(at) & ((1 << 14) - 1) != FLAGS) continue;
            assembly ("memory-safe") {
                h := create2(0, add(code, 32), mload(code), salt)
            }
            require(address(h) != address(0), "hook deploy");
            return h;
        }
        revert("salt");
    }

    function test_buybackLocksForeverWhenUnlockedBudgetExceedsPoolDepth() public {
        // One epoch of ordinary treasury income: 2 ETH, of which 40% (0.8 ETH) is the buyback budget.
        (bool ok,) = address(treasury).call{value: 2 ether}("");
        assertTrue(ok);
        vm.warp(treasury.epochEnd(0));
        treasury.settle(0);
        assertEq(treasury.buybackReserved(), 0.8 ether);

        // Nobody calls buyback during the 24h unlock. All 0.8 ETH is now unlocked at once.
        vm.warp(vm.getBlockTimestamp() + 1 days);
        (uint256 unlocked,) = treasury.buybackChunk();
        assertEq(unlocked, 0.8 ether);

        // The pool cannot absorb 0.8 ETH within 5% of the TWAP. Time passing changes nothing: the unspent
        // amount only carries over, so the same whole-budget swap is attempted on every later call.
        vm.warp(vm.getBlockTimestamp() + 30 days);
        uint256 reservedBefore = treasury.buybackReserved();
        assertEq(reservedBefore, 0.8 ether);
        assertEq(treasury.freeETH(), 2 ether - 0.8 ether);

        // Expected: buyback spends what the pool can absorb within the bound and leaves the rest unlocked,
        // so the call succeeds and the locked reserve shrinks. Actual: revert("slippage") forever.
        treasury.buyback();
        assertLt(treasury.buybackReserved(), reservedBefore, "buyback must make progress on the reserve");
    }

    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {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} from "v4-core/src/types/PoolOperation.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {MediciToken} from "src/MediciToken.sol";
import {MediciHook} from "src/MediciHook.sol";
import {MediciTreasury} from "src/MediciTreasury.sol";

/// @dev Minimal LP that seeds the launch pool with full-range liquidity.
contract LP is IUnlockCallback {
    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function add(PoolKey memory key, int256 liquidity) external {
        manager.unlock(abi.encode(key, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (PoolKey memory key, int256 liquidity) = abi.decode(data, (PoolKey, int256));
        (BalanceDelta delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, liquidity, 0), "");
        if (delta.amount0() < 0) {
            manager.sync(key.currency0);
            manager.settle{value: uint256(-int256(delta.amount0()))}();
        }
        if (delta.amount1() < 0) {
            manager.sync(key.currency1);
            IERC20(Currency.unwrap(key.currency1)).transfer(address(manager), uint256(-int256(delta.amount1())));
            manager.settle();
        }
        return "";
    }

    receive() external payable {}
}

/// Finding: buyback() swaps ALL unlocked ETH in one exact-input swap with a 5% min-out from the
/// 24h TWAP. Once the unlocked amount exceeds what the pool can absorb within 5% of the TWAP,
/// buyback() reverts "slippage" and can never succeed again: the unlocked amount only grows
/// (vesting continues, unspent carries over, every settle adds a chunk), there is no partial
/// buyback, and the contract is immutable. The ETH is counted in buybackReserved and so is also
/// excluded from freeETH(), i.e. from bounties, the IMD purchase and keeperWithdraw.
///
/// Fails now with "slippage". Passes once buyback() can spend the budget in slices that respect
/// the min-out (for example, cap each call to the largest amount whose quote clears the bound).
contract BuybackLockTest is Test {
    PoolManager manager;
    MediciToken token;
    MediciHook hook;
    MediciTreasury treasury;
    PoolKey key;
    uint64 opened;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.deal(address(this), 10000 ether);
        manager = new PoolManager(address(this));
        token = new MediciToken();
        hook = _deployHook(manager, token, address(this), 777);
        treasury = hook.treasury();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 12500, 60, IHooks(address(hook)));
        // 10 ETH opening market cap / 1 billion MEDICI: sqrt(token/ETH) = 10,000.
        manager.initialize(key, uint160(uint256(1 << 96) * 10000));
        opened = hook.openedAt();
        LP lp = new LP(manager);
        vm.deal(address(lp), 1000 ether);
        token.transfer(address(lp), 500_000_000 ether);
        lp.add(key, 4e22); // full range: ~4 ETH / 400M MEDICI virtual reserves at the opening price
    }

    function _deployHook(IPoolManager m, MediciToken t, address f, uint64 n) internal returns (MediciHook h) {
        bytes memory code = abi.encodePacked(type(MediciHook).creationCode, abi.encode(m, address(t), f, n));
        bytes32 hash = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address at = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, hash)))));
            if (uint160(at) & ((1 << 14) - 1) != FLAGS) continue;
            assembly ("memory-safe") {
                h := create2(0, add(code, 32), mload(code), salt)
            }
            require(address(h) != address(0), "hook deploy");
            return h;
        }
        revert("salt");
    }

    function _income(uint256 amount) internal {
        (bool ok,) = address(treasury).call{value: amount}("");
        assertTrue(ok);
    }

    /// Twelve epochs of 1 ETH fee income each, nobody calling buyback meanwhile (the 0.5% tip on a
    /// 0.4 ETH chunk is 0.002 ETH, below mainnet gas for the call). 4.8 ETH of buyback budget
    /// accumulates against a pool holding ~4 ETH. The single swap would return ~45% of the TWAP
    /// amount, so buyback() reverts "slippage"; nothing can ever reduce the amount it must swap.
    function test_buybackCanSpendAccumulatedBudget() public {
        for (uint256 e; e < 12; ++e) {
            vm.warp(opened + e * 7 days + 1 days);
            _income(1 ether);
            vm.warp(treasury.epochEnd(e));
            treasury.settle(e);
        }
        vm.warp(block.timestamp + 2 days);
        (uint256 unlocked,) = treasury.buybackChunk();
        assertEq(unlocked, 4.8 ether, "40% of 12 ETH is unlocked");
        assertEq(treasury.buybackReserved(), 4.8 ether);
        assertEq(treasury.freeETH(), 7.2 ether, "the reserved ETH is outside freeETH");
        uint256 burnedBefore = treasury.totalBuybackBurned();

        // Expected: unlocked ETH is spent (possibly partially) and MEDICI is burned.
        // Actual on current code: revert "slippage", now and forever.
        treasury.buyback();
        assertGt(treasury.totalBuybackBurned(), burnedBefore, "buyback burned MEDICI");
        assertLt(treasury.buybackReserved(), 4.8 ether, "some reserved ETH was spent");
    }

    receive() external payable {}
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;
import {Test} from "forge-std/Test.sol";
import {MediciTreasury} from "src/MediciTreasury.sol";
import {MediciToken} from "src/MediciToken.sol";
import {Protocol} from "src/Protocol.sol";
import {IIntake} from "src/interfaces/IProtocol.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract UriProofHistory {
    uint64 public immutable openedAt;
    constructor(uint64 time) { openedAt = time; }
    function twap(uint64, uint64) external pure returns (uint256) { return 1e10; }
}
contract UriProofIntake is IIntake {
    uint256 private nonce;
    function requestWithFailure(bytes32, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external payable returns (bytes32)
    {
        require(IERC20(asset).transferFrom(msg.sender, address(this), amount));
        return keccak256(abi.encode(msg.sender, ++nonce));
    }
}

/// @notice A valid live success callback must store the supplied URI within 200,000 gas.
/// The task gives no 96-byte bound. This 97-byte HTTPS URI is not oversized by any task rule.
contract ResultUriProof is Test {
    function test_liveResultWith97ByteURIIsStoredUnderStipend() public {
        uint64 opened = 1800000000;
        vm.warp(opened + 1);
        MediciToken medici = new MediciToken();
        PoolManager manager = new PoolManager(address(this));
        UriProofHistory history = new UriProofHistory(opened);
        MediciTreasury treasury = new MediciTreasury(address(medici), IPoolManager(address(manager)), address(history));
        medici.approve(address(treasury), type(uint256).max);
        bytes memory brief = '{"name":"URI proof"}';
        treasury.propose("URI proof", brief);
        treasury.vote(0, 1, 2_000_000 ether);
        vm.warp(treasury.epochEnd(0));
        treasury.settle(0);
        vm.etch(Protocol.IMD, address(new MediciToken()).code);
        deal(Protocol.IMD, address(treasury), 0.5 ether);
        vm.etch(Protocol.INTAKE, address(new UriProofIntake()).code);
        vm.prank(Protocol.KEEPER);
        bytes32 request = treasury.commission(0, brief);
        bytes memory uri = new bytes(97);
        bytes memory prefix = bytes("https://example.org/results/");
        for (uint256 i; i < uri.length; ++i) uri[i] = i < prefix.length ? prefix[i] : bytes1("a");
        bytes32 hash = keccak256("result");
        vm.cool(address(treasury));
        vm.prank(Protocol.INTAKE);
        (bool ok,) = address(treasury).call{gas: 200000}(abi.encodeCall(treasury.onResult, (request, hash, string(uri))));
        assertTrue(ok, "valid live 97-byte result URI must not be discarded");
        (bytes32 storedRequest, bytes32 storedHash, string memory storedURI) = treasury.resultOf(0);
        assertEq(storedRequest, request);
        assertEq(storedHash, hash);
        assertEq(storedURI, string(uri));
    }
}