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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice A burn bucket of one paired minor unit cannot be cleared by any permissionless outlet: the 1.25% LP
/// fee rounds a one-unit swap's usable input to zero, the buyback returns zero PANIC and reverts, and the other
/// outlets cannot touch the burn bucket. Fails on the current code; passes once accrued dust has a clearing path.
contract DustBucketTest is Test {
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant TICK_SPACING = 100;
    address constant ORACLE_FUND = 0x788C311500FD3C15b8e44d6e2935fe7fF13E674b;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), ORACLE_FUND)
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), ORACLE_FUND);
        assertEq(address(hook), predicted);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: 12_500,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e25}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(1e22),
                salt: 0
            }),
            ""
        );
    }

    function test_oneUnitBurnBucketHasAPermissionlessClearingPath() public {
        // Sell 600 PANIC minor units: gross output 591, hook fee 11 -> oracle 7, donated 3, burn 1.
        swapRouter.swap(
            key,
            SwapParams({zeroForOne: false, amountSpecified: -600, sqrtPriceLimitX96: TickMath.MAX_SQRT_PRICE - 1}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
        assertEq(hook.burnBucket(), 1, "one unit accrued to the burn bucket");

        // An hour later, flat price: every outlet is tried.
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 3600);
        hook.claimOracleFund();
        (bool okDonate,) = address(hook).call(abi.encodeWithSignature("donateToLiquidityProviders()"));
        okDonate;
        (bool okBuyback, bytes memory ret) = address(hook).call(abi.encodeWithSignature("buybackAndBurn()"));
        if (!okBuyback) emit log_named_bytes("buybackAndBurn() reverted with", ret);
        (bool okBuybackOne,) = address(hook).call(abi.encodeWithSignature("buybackAndBurn(uint256)", uint256(1)));
        okBuybackOne;

        emit log_named_uint("burnBucket after every outlet", hook.burnBucket());
        emit log_named_uint("claims still held by the hook", manager.balanceOf(address(hook), 0));
        assertEq(hook.totalAccruedFees(), 0, "accrued dust stays stuck in the burn bucket");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency, CurrencyLibrary} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {FullMath} from "v4-core/src/libraries/FullMath.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PanicMonkeys} from "src/PanicMonkeys.sol";
import {PanicHook} from "src/PanicHook.sol";
import {HookMiner} from "src/HookMiner.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice `_buybackAndBurn` floors the reference-implied PANIC before applying the 98% minimum, so
/// ceil(0.98 * floor(q)) can be one unit below ceil(0.98 * q). With the live price 3% above the reference a
/// 1000-unit buyback returning 20 PANIC units is accepted although 98% of the exact quote (20.8999...) is 20.48,
/// which requires 21. Fails on the current code; passes once the minimum is derived from the unfloored quote.
contract BuybackFloorRoundingTest is Test {
    using StateLibrary for IPoolManager;

    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    int24 constant TICK_SPACING = 100;
    address constant ORACLE_FUND = 0x788C311500FD3C15b8e44d6e2935fe7fF13E674b;

    PoolManager manager;
    PanicMonkeys panic;
    PanicHook hook;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1_000);
        manager = new PoolManager(address(this));
        panic = new PanicMonkeys();
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));

        bytes memory creationCode = abi.encodePacked(
            type(PanicHook).creationCode, abi.encode(IPoolManager(address(manager)), address(panic), ORACLE_FUND)
        );
        (address predicted, bytes32 salt) =
            HookMiner.find(address(this), HookFlags.PANIC_HOOK, creationCode, 0, 1_000_000);
        hook = new PanicHook{salt: salt}(IPoolManager(address(manager)), address(panic), ORACLE_FUND);
        assertEq(address(hook), predicted);

        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(panic)),
            fee: 12_500,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, SQRT_PRICE_1_1);

        vm.deal(address(this), 1e27);
        panic.approve(address(swapRouter), type(uint256).max);
        panic.approve(address(lpRouter), type(uint256).max);
        lpRouter.modifyLiquidity{value: 1e25}(
            key,
            ModifyLiquidityParams({
                tickLower: TickMath.minUsableTick(TICK_SPACING),
                tickUpper: TickMath.maxUsableTick(TICK_SPACING),
                liquidityDelta: int256(1e22),
                salt: 0
            }),
            ""
        );
    }

    function _swap(bool zeroForOne, int256 amountSpecified, uint160 limit) internal {
        uint256 value = zeroForOne ? uint256(-amountSpecified) : 0;
        swapRouter.swap{value: value}(
            key,
            SwapParams({zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: limit}),
            PoolSwapTest.TestSettings({takeClaims: false, settleUsingBurn: false}),
            ""
        );
    }

    function test_smallBuybackThreePercentAboveReferenceMustRevert() public {
        _swap(false, -1e18, TickMath.MAX_SQRT_PRICE - 1); // sell 1 PANIC: funds the burn bucket
        _swap(true, -1e24, 11453882584939555244670964355); // buy up to a limit
        vm.roll(block.number + 1);
        vm.warp(block.timestamp + 3600); // flat for an hour: reference == this price
        _swap(true, -1e24, 11285843134733390162692706488); // buy: live PANIC price 3% above the reference

        uint160 ref = hook.referenceSqrtPriceX96();
        (uint160 live,,,) = IPoolManager(address(manager)).getSlot0(key.toId());
        uint256 premiumE4 = uint256(ref) * uint256(ref) / uint256(live) * 10_000 / uint256(live);
        emit log_named_uint("live PANIC price / reference (e4)", premiumE4);
        assertGt(premiumE4, 10_200, "more than 2% above the reference");

        // Exact reference quote for 1000 paired units, in millionths of a PANIC unit.
        uint256 quoteE6 = FullMath.mulDiv(FullMath.mulDiv(1000 * 1e6, ref, 1 << 96), ref, 1 << 96);
        uint256 minimumExact = (quoteE6 * 9800 + 1e10 - 1) / 1e10; // ceil(0.98 * quote)
        emit log_named_uint("exact quote (e6)", quoteE6);
        emit log_named_uint("floored quote used by the hook", hook.pairedToPanicAtSqrtPrice(1000, ref, false));
        emit log_named_uint("minimum from the exact quote", minimumExact);
        assertEq(minimumExact, 21);

        vm.expectRevert();
        hook.buybackAndBurn(1000);
    }
}