// 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} from "v4-core/src/types/PoolOperation.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {BMCSwapRouter} from "src/BMCSwapRouter.sol";
import {HookDeployer} from "src/HookDeployer.sol";

contract RejectsEth {
    receive() external payable {
        revert("no ETH");
    }
}

/// The brief's community wallet 0x83027AD9d0D5374335086c539dADD1db983441B0 is, on mainnet today, an
/// EIP-7702 delegated account (code 0xef0100 || 0x000000005c84f8fd50b21cac312528a64437030e). Its
/// holder can re-delegate it to code that reverts on receiving ETH (or burns the call's gas). The hook
/// pushes the buy fee to it inside the swap, so from then on every buy on the pool reverts and the
/// immutable hook cannot be repointed. Expected: the buy succeeds and the fee is kept as a claim.
contract RejectingRecipientProof is Test {
    address constant COMMUNITY_WALLET = 0x83027AD9d0D5374335086c539dADD1db983441B0;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96;
    PoolManager manager;
    BMCHook hook;
    BMCSwapRouter router;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        BMCToken token = new BMCToken();
        router = new BMCSwapRouter(IPoolManager(address(manager)));
        PoolModifyLiquidityTest lp = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        bytes memory code = abi.encodePacked(
            type(BMCHook).creationCode,
            abi.encode(address(manager), address(token), COMMUNITY_WALLET, uint256(100), uint256(100))
        );
        hook = BMCHook(HookDeployer.deploy(code, BMC_HOOK_FLAGS));
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, OPENING_SQRT_PRICE);
        token.approve(address(lp), type(uint256).max);
        vm.deal(address(this), 2 ether);
        lp.modifyLiquidity{value: 1.1 ether}(key, ModifyLiquidityParams(-887_220, 887_220, 1e22, 0), "");
        // The wallet's delegate now rejects ETH.
        vm.etch(COMMUNITY_WALLET, address(new RejectsEth()).code);
    }

    function test_buyStillWorksWhenTheWalletRejectsEth() public {
        address buyer = makeAddr("buyer");
        vm.deal(buyer, 1 ether);
        vm.prank(buyer);
        uint256 out = router.buyExactIn{value: 0.1 ether}(key, 0);
        assertGt(out, 0, "the buy should go through");
    }

    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 {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} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {BMCSwapRouter} from "src/BMCSwapRouter.sol";
import {HookFlags} from "src/HookFlags.sol";

/// @notice BMCHook.beforeSwap burns 1% of the *specified* input of an exact-input sell before the pool
/// fills it. The launch pool is seeded with BMC only, below the opening price, so there is never ETH
/// liquidity above that price: a sell that would push the price past it only partly fills, the unfilled
/// BMC is refunded to the seller, and 1% of that refunded BMC has already been burned. At the ceiling
/// (no ETH in the pool) a sell fills nothing and still burns 1% of the whole input.
///
/// Fails on the current code. Passes once the hook either refuses a partly-filled exact-input swap or
/// burns only 1% of the BMC the pool actually took (the test accepts a revert or a corrected burn).
contract ProofPartialFillBurnTest is Test {
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96; // 1e8 BMC per ETH: 1e9 BMC = 10 ETH
    int24 constant MIN_USABLE_TICK = -887_220;

    address feeRecipient = makeAddr("communityWallet");
    address buyer = makeAddr("buyer");
    address seller = makeAddr("seller");

    PoolManager manager;
    BMCToken token;
    BMCHook hook;
    BMCSwapRouter router;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new BMCToken();
        router = new BMCSwapRouter(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        hook = BMCHook(_deployHook());
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, OPENING_SQRT_PRICE);

        // Token-only liquidity below the opening price, the way the launch seeds its pool (no ETH).
        token.approve(address(lpRouter), type(uint256).max);
        int24 upper = (TickMath.getTickAtSqrtPrice(OPENING_SQRT_PRICE) / TICK_SPACING) * TICK_SPACING;
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(MIN_USABLE_TICK, upper, int256(1e22), 0), "");

        vm.deal(buyer, 10 ether);
        token.transfer(seller, 200_000_000 ether);
        vm.prank(seller);
        token.approve(address(router), type(uint256).max);
    }

    /// Pool at the ceiling (no ETH at all): selling 1,000,000 BMC fills nothing. Expected: nothing burned,
    /// nothing paid (or the swap refused). Actual: 10,000 BMC burned, 0 ETH received.
    function test_sellWithNoEthLiquidity_mustNotBurnForZeroOutput() public {
        uint256 tokensIn = 1_000_000 ether;
        uint256 supplyBefore = token.totalSupply();
        uint256 sellerBefore = token.balanceOf(seller);
        uint256 ethBefore = seller.balance;

        vm.prank(seller);
        try router.sellExactIn(key, tokensIn, 0) {} catch {}

        uint256 burned = supplyBefore - token.totalSupply();
        uint256 sellerPaid = sellerBefore - token.balanceOf(seller);
        assertEq(seller.balance - ethBefore, 0, "the pool had no ETH: nothing could be filled");
        assertEq(burned, 0, "1% of a sale that filled nothing was burned");
        assertEq(sellerPaid, 0, "the seller paid BMC for zero ETH");
    }

    /// After one 1 ETH buy, a sell of twice the BMC that buy produced can only fill back to the opening
    /// price. Expected: the burn is 1% of the BMC the pool actually took (fee = filled / 99 when the fee
    /// comes off the input). Actual: 1% of the whole specified amount, so ~half the burn is on BMC that
    /// was refunded to the seller.
    function test_partialFillSell_mustBurnOnlyOnePercentOfWhatWasSold() public {
        vm.prank(buyer);
        uint256 bought = router.buyExactIn{value: 1 ether}(key, 0);

        uint256 tokensIn = 2 * bought;
        uint256 supplyBefore = token.totalSupply();
        uint256 sellerBefore = token.balanceOf(seller);

        vm.prank(seller);
        try router.sellExactIn(key, tokensIn, 0) {} catch {}

        uint256 burned = supplyBefore - token.totalSupply();
        uint256 sellerPaid = sellerBefore - token.balanceOf(seller);
        uint256 filled = sellerPaid - burned; // what the pool actually took from the seller
        assertLt(filled, tokensIn - burned, "sanity: the sale only partly filled (price ceiling)");
        // 1 BMC of tolerance for rounding in a corrected implementation; the current code is off by ~480,000 BMC.
        assertLe(burned, filled / 99 + 1 ether, "burn exceeds 1% of the BMC actually sold");
    }

    function _deployHook() internal returns (address at) {
        bytes memory creationCode = abi.encodePacked(
            type(BMCHook).creationCode,
            abi.encode(address(manager), address(token), feeRecipient, uint256(100), uint256(100))
        );
        bytes32 initCodeHash = keccak256(creationCode);
        for (uint256 i = 0; i < 500_000; i++) {
            address predicted = address(
                uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initCodeHash))))
            );
            if (!HookFlags.matches(predicted, BMC_HOOK_FLAGS) || predicted.code.length != 0) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
            }
            require(at == predicted, "hook landed elsewhere");
            return at;
        }
        revert("no salt");
    }
}

// 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} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {BMCSwapRouter} from "src/BMCSwapRouter.sol";
import {HookDeployer} from "src/HookDeployer.sol";

/// @notice Exact-input swaps are charged in `beforeSwap` as 1% of the amount *requested*, before the pool
/// fills. On the launch geometry (BMC-only liquidity below the opening tick) the pool only ever holds the
/// ETH buyers put in, so a sale larger than that fills partially (or not at all), yet the full 1% of the
/// requested amount is burned. Exact-output sales, charged in `afterSwap` on the pool's real amount, do not
/// have this problem. Both tests fail on the current code and pass once the exact-input fee is computed
/// from the amount actually filled.
abstract contract LaunchPoolFixture is Test {
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96; // 1e8 BMC per ETH (10 ETH market cap)
    int24 constant MIN_USABLE_TICK = -887_220;

    address feeRecipient = makeAddr("communityWallet");
    address buyer = makeAddr("buyer");
    address seller = makeAddr("seller");

    PoolManager manager;
    BMCToken token;
    BMCHook hook;
    BMCSwapRouter router;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function deployLaunchPool() internal {
        manager = new PoolManager(address(this));
        token = new BMCToken();
        router = new BMCSwapRouter(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        bytes memory creationCode = abi.encodePacked(
            type(BMCHook).creationCode, abi.encode(address(manager), address(token), feeRecipient, uint256(100), uint256(100))
        );
        hook = BMCHook(HookDeployer.deploy(creationCode, BMC_HOOK_FLAGS));
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, OPENING_SQRT_PRICE);

        // The launch seeds tokens only, below the opening price: no ETH is in the pool until someone buys.
        token.approve(address(lpRouter), type(uint256).max);
        int24 upper = (TickMath.getTickAtSqrtPrice(OPENING_SQRT_PRICE) / TICK_SPACING) * TICK_SPACING;
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(MIN_USABLE_TICK, upper, int256(1e22), 0), "");

        // A holder (airdrop / launcher allocation) who will sell through the project's router.
        token.transfer(seller, 100_000_000 ether);
        vm.prank(seller);
        token.approve(address(router), type(uint256).max);
    }
}

contract PartialFillSellTest is LaunchPoolFixture {
    function setUp() public {
        deployLaunchPool();
        // One buyer puts 0.1 ETH in; that is all the ETH the pool holds.
        vm.deal(buyer, 1 ether);
        vm.prank(buyer);
        router.buyExactIn{value: 0.1 ether}(key, 0);
    }

    function test_exactInputSellBurnsOnePercentOfTheRequestedAmountNotOfWhatWasSold() public {
        uint256 tokensIn = 100_000_000 ether;
        uint256 supplyBefore = token.totalSupply();
        uint256 sellerBefore = token.balanceOf(seller);
        uint256 managerBefore = token.balanceOf(address(manager));

        vm.prank(seller);
        uint256 ethOut = router.sellExactIn(key, tokensIn, 0);

        uint256 burned = supplyBefore - token.totalSupply();
        uint256 leftWallet = sellerBefore - token.balanceOf(seller); // what the sale actually cost the seller
        uint256 soldToPool = token.balanceOf(address(manager)) - managerBefore; // what the pool actually bought

        emit log_named_uint("eth received", ethOut);
        emit log_named_uint("tokens the pool bought", soldToPool);
        emit log_named_uint("tokens burned", burned);
        emit log_named_uint("tokens that left the seller", leftWallet);

        assertGt(ethOut, 0, "the sale went through (partially)");
        assertLt(soldToPool, tokensIn / 2, "the pool could absorb only a small part of the order");

        // Brief: "burns 1% of the BMC tokens being sold". The burn must be at most 1% of what the seller
        // actually parted with. On the current code it is 1% of the 100M requested: about 10% of the sale.
        assertLe(burned * 100, leftWallet, "burn exceeds 1% of the tokens actually sold");
    }
}

contract ZeroFillSellTest is LaunchPoolFixture {
    function setUp() public {
        deployLaunchPool(); // nobody has bought yet: the pool holds no ETH at all
    }

    function test_firstSaleOnTheLaunchPoolBurnsOnePercentAndPaysNothing() public {
        uint256 supplyBefore = token.totalSupply();
        uint256 walletBefore = token.balanceOf(seller);

        vm.prank(seller);
        uint256 ethOut = router.sellExactIn(key, 10_000_000 ether, 0);

        uint256 burned = supplyBefore - token.totalSupply();
        uint256 lost = walletBefore - token.balanceOf(seller);
        emit log_named_uint("eth received", ethOut);
        emit log_named_uint("tokens burned", burned);
        emit log_named_uint("tokens lost by the seller", lost);

        assertEq(ethOut, 0, "the pool had no ETH: nothing was sold");
        assertEq(lost, burned, "the only thing the seller lost was the burn");
        assertEq(burned, 0, "a sale that sold nothing must burn nothing");
    }
}

// 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 {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {HookDeployer} from "src/HookDeployer.sol";

/// @notice Exact-input swaps are charged 1% of the amount the swapper *specified* in `beforeSwap`, before the
/// pool fills. When the fill stops early (price limit hit, liquidity exhausted) the pool consumes only part of
/// the input, but the whole fee stays: the community wallet receives far more than 1% of the ETH side, and the
/// sell burn destroys far more than 1% of the BMC actually sold.
contract PartialFillFeeTest is Test {
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96;
    int24 constant MIN_USABLE_TICK = -887_220;
    int24 constant MAX_USABLE_TICK = 887_220;

    address feeRecipient = makeAddr("communityWallet");
    address trader = makeAddr("trader");

    PoolManager manager;
    BMCToken token;
    BMCHook hook;
    PoolModifyLiquidityTest lpRouter;
    PoolSwapTest swapRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new BMCToken();
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        swapRouter = new PoolSwapTest(IPoolManager(address(manager)));
        bytes memory creationCode = abi.encodePacked(
            type(BMCHook).creationCode, abi.encode(address(manager), address(token), feeRecipient, uint256(100), uint256(100))
        );
        hook = BMCHook(HookDeployer.deploy(creationCode, BMC_HOOK_FLAGS));
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, OPENING_SQRT_PRICE);
        // Full-range, two-sided liquidity: about 1 ETH and 100,000,000 BMC at the opening price.
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 10 ether);
        lpRouter.modifyLiquidity{value: 1.1 ether}(
            key, ModifyLiquidityParams(MIN_USABLE_TICK, MAX_USABLE_TICK, int256(1e22), 0), ""
        );
        vm.deal(trader, 10 ether);
        token.transfer(trader, 10_000_000 ether);
        vm.prank(trader);
        token.approve(address(swapRouter), type(uint256).max);
    }

    /// Buy 1 ETH exact-input with a price limit 0.1% below the current price (any router that exposes
    /// `sqrtPriceLimitX96`, e.g. the Universal Router, lets a trader set this). The pool consumes about
    /// 0.001 ETH; the trader is charged a 0.01 ETH fee: 1% of what was *typed*, roughly 1000% of what was traded.
    function test_exactInputBuy_partialFill_feeIsOnePercentOfTheEthActuallyTraded() public {
        uint256 managerEthBefore = address(manager).balance;
        uint160 limit = uint160((uint256(OPENING_SQRT_PRICE) * 999) / 1000);
        SwapParams memory params = SwapParams({zeroForOne: true, amountSpecified: -1 ether, sqrtPriceLimitX96: limit});

        vm.prank(trader);
        try swapRouter.swap{value: 1 ether}(key, params, PoolSwapTest.TestSettings(false, false), "") returns (
            BalanceDelta delta
        ) {
            uint256 paidByTrader = uint256(uint128(-delta.amount0()));
            uint256 feePaid = feeRecipient.balance + hook.pendingEthFees();
            uint256 ethToPool = address(manager).balance - managerEthBefore - hook.pendingEthFees();
            assertEq(paidByTrader, ethToPool + feePaid, "trader paid the pool's ETH plus the fee");
            assertLt(ethToPool, 0.01 ether, "the fill really was partial (far less than the 1 ETH typed)");
            // The rule is 1% of the ETH side of the trade. Allow 2% of the ETH that actually went to the pool.
            assertLe(feePaid, (ethToPool * 2) / 100, "fee must be ~1% of the ETH actually traded, not of the input typed");
        } catch {
            // A hook that refuses partial exact-input fills instead of over-charging also satisfies the rule.
            assertEq(feeRecipient.balance + hook.pendingEthFees(), 0, "a refused trade pays no fee");
        }
    }

    /// Sell 1,000,000 BMC exact-input with a price limit 0.1% above the current price. The pool takes about
    /// 100,000 BMC; 10,000 BMC are burned: 1% of what was typed, about 10% of what was actually sold.
    function test_exactInputSell_partialFill_burnIsOnePercentOfTheTokensActuallySold() public {
        uint256 supplyBefore = token.totalSupply();
        uint256 managerTokensBefore = token.balanceOf(address(manager));
        uint160 limit = uint160((uint256(OPENING_SQRT_PRICE) * 1001) / 1000);
        SwapParams memory params =
            SwapParams({zeroForOne: false, amountSpecified: -int256(1_000_000 ether), sqrtPriceLimitX96: limit});

        vm.prank(trader);
        try swapRouter.swap(key, params, PoolSwapTest.TestSettings(false, false), "") returns (BalanceDelta delta) {
            uint256 paidByTrader = uint256(uint128(-delta.amount1()));
            uint256 burned = (supplyBefore - token.totalSupply()) + hook.pendingBurns();
            uint256 tokensToPool = token.balanceOf(address(manager)) - managerTokensBefore - hook.pendingBurns();
            assertEq(paidByTrader, tokensToPool + burned, "trader paid the pool's BMC plus the burn");
            assertLt(tokensToPool, 500_000 ether, "the fill really was partial");
            assertLe(burned, (tokensToPool * 2) / 100, "burn must be ~1% of the BMC actually sold, not of the input typed");
        } catch {
            assertEq(token.totalSupply() + hook.pendingBurns(), supplyBefore, "a refused trade burns nothing");
        }
    }
}

// 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} from "v4-core/src/types/PoolOperation.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {BMCSwapRouter} from "src/BMCSwapRouter.sol";
import {HookDeployer} from "src/HookDeployer.sol";

/// @dev Stands in for the community wallet once its code no longer accepts plain ETH. The launch's recipient
/// 0x83027AD9d0D5374335086c539dADD1db983441B0 is an EIP-7702 delegated account on mainnet (code 0xef0100…),
/// so what runs when the hook pushes ETH to it is whatever contract it is delegated to at that moment.
contract RejectingWallet {
    fallback() external payable {
        revert("no plain ETH");
    }
}

/// @notice When the PoolManager holds ETH (always, on mainnet) the hook pushes the buy fee with `take`, which
/// reverts the whole swap if the recipient refuses ETH. There is no fallback to the claim path, so every buy
/// on the pool reverts for as long as the recipient's code rejects ETH, and `collect()` reverts too.
contract RecipientRejectsEthTest is Test {
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96;
    int24 constant MIN_USABLE_TICK = -887_220;
    int24 constant MAX_USABLE_TICK = 887_220;

    address trader = makeAddr("trader");

    PoolManager manager;
    BMCToken token;
    BMCHook hook;
    BMCSwapRouter router;
    PoolModifyLiquidityTest lpRouter;
    RejectingWallet recipient;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new BMCToken();
        router = new BMCSwapRouter(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        recipient = new RejectingWallet();
        bytes memory creationCode = abi.encodePacked(
            type(BMCHook).creationCode,
            abi.encode(address(manager), address(token), address(recipient), uint256(100), uint256(100))
        );
        hook = BMCHook(HookDeployer.deploy(creationCode, BMC_HOOK_FLAGS));
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, OPENING_SQRT_PRICE);
        token.approve(address(lpRouter), type(uint256).max);
        vm.deal(address(this), 10 ether);
        lpRouter.modifyLiquidity{value: 1.1 ether}(
            key, ModifyLiquidityParams(MIN_USABLE_TICK, MAX_USABLE_TICK, int256(1e22), 0), ""
        );
        vm.deal(trader, 10 ether);
    }

    /// The manager holds about 1 ETH, so the hook takes the fee directly; the recipient reverts; the buy reverts.
    /// Expected: the trade goes through and the fee is parked as an ERC-6909 claim (`pendingEthFees`).
    function test_buyStillSucceedsWhenTheRecipientRejectsEth() public {
        assertGt(address(manager).balance, 0.001 ether, "the manager can cover the fee, so the direct path is taken");
        uint256 supplyBefore = token.totalSupply();

        vm.prank(trader);
        (bool ok, bytes memory ret) =
            address(router).call{value: 0.1 ether}(abi.encodeCall(BMCSwapRouter.buyExactIn, (key, 0)));
        assertTrue(ok, string(abi.encodePacked("the buy reverted because the fee recipient refused ETH: ", ret)));

        assertGt(token.balanceOf(trader), 0, "the trader received BMC");
        assertEq(hook.pendingEthFees(), 0.001 ether, "the 1% fee is held as a claim instead of blocking the swap");
        assertEq(token.totalSupply(), supplyBefore, "buys burn nothing");
    }

    /// Exact-output buys take the same `take` path in `afterSwap`.
    function test_exactOutputBuyStillSucceedsWhenTheRecipientRejectsEth() public {
        vm.prank(trader);
        (bool ok,) =
            address(router).call{value: 1 ether}(abi.encodeCall(BMCSwapRouter.buyExactOut, (key, 1_000_000 ether)));
        assertTrue(ok, "the exact-output buy reverted because the fee recipient refused ETH");
        assertGt(hook.pendingEthFees(), 0, "the fee is held as a claim");
    }
}

// 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} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {BMCSwapRouter} from "src/BMCSwapRouter.sol";
import {HookDeployer} from "src/HookDeployer.sol";

/// @notice The launch pool is seeded with BMC only, below the opening price. Until buys put ETH into
/// it, a sale can only be filled by whatever ETH earlier buys left. BMCHook charges the sell burn in
/// `beforeSwap` as 1% of the amount *requested*, before the pool fills, so a sale the pool can only
/// partly (or not at all) absorb still burns 1% of the full request. The brief says the hook "burns 1%
/// of the BMC tokens being sold". The tests below fail on the current code and pass once the burn is
/// 1% of what the pool actually took, or once a swap that cannot be filled in full is refused.
contract PartialFillOverchargeTest is Test {
    uint24 constant LP_FEE = 12_500;
    int24 constant TICK_SPACING = 60;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96; // 1e8 BMC per ETH: 1e9 BMC = 10 ETH
    int24 constant MIN_USABLE_TICK = -887_220;

    address feeRecipient = makeAddr("communityWallet");
    address holder = makeAddr("airdropHolder");
    address buyer = makeAddr("buyer");

    PoolManager manager;
    BMCToken token;
    BMCHook hook;
    BMCSwapRouter router;
    PoolModifyLiquidityTest lpRouter;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new BMCToken();
        router = new BMCSwapRouter(IPoolManager(address(manager)));
        lpRouter = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        bytes memory creationCode = abi.encodePacked(
            type(BMCHook).creationCode, abi.encode(address(manager), address(token), feeRecipient, uint256(100), uint256(100))
        );
        hook = BMCHook(HookDeployer.deploy(creationCode, BMC_HOOK_FLAGS));
        key = PoolKey({
            currency0: CurrencyLibrary.ADDRESS_ZERO,
            currency1: Currency.wrap(address(token)),
            fee: LP_FEE,
            tickSpacing: TICK_SPACING,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, OPENING_SQRT_PRICE);

        // The launch seeds BMC only, from the floor up to the opening tick: no ETH in the pool yet.
        token.approve(address(lpRouter), type(uint256).max);
        int24 upper = (TickMath.getTickAtSqrtPrice(OPENING_SQRT_PRICE) / TICK_SPACING) * TICK_SPACING;
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(MIN_USABLE_TICK, upper, int256(1e22), 0), "");

        // An airdrop recipient holding BMC, and a buyer with ETH.
        token.transfer(holder, 50_000_000 ether);
        vm.deal(buyer, 10 ether);
        vm.prank(holder);
        token.approve(address(router), type(uint256).max);
    }

    /// @dev Burn must be 1% of what the pool actually took from the seller, or the sale must be refused.
    function _sellAndCheck(uint256 tokensIn) internal {
        uint256 supplyBefore = token.totalSupply();
        uint256 holderBefore = token.balanceOf(holder);
        uint256 poolBefore = token.balanceOf(address(manager));

        vm.prank(holder);
        try router.sellExactIn(key, tokensIn, 0) returns (uint256 ethOut) {
            uint256 burned = supplyBefore - token.totalSupply();
            uint256 soldToPool = token.balanceOf(address(manager)) - poolBefore;
            emit log_named_uint("requested", tokensIn);
            emit log_named_uint("taken by the pool", soldToPool);
            emit log_named_uint("eth received", ethOut);
            emit log_named_uint("burned", burned);
            assertEq(holderBefore - token.balanceOf(holder), soldToPool + burned, "seller paid pool + burn");
            assertEq(burned, soldToPool / 100, "the burn is 1% of the BMC actually sold");
        } catch {
            assertEq(token.totalSupply(), supplyBefore, "a refused sale burns nothing");
            assertEq(token.balanceOf(holder), holderBefore, "a refused sale takes nothing");
        }
    }

    /// @notice No buy has happened: the pool holds no ETH. The seller receives 0 ETH, sells nothing,
    /// and still loses 1% of the requested amount to the burn.
    function test_saleIntoAPoolWithNoEthStillBurnsOnePercent() public {
        assertEq(address(manager).balance, 0, "no ETH in the pool before any buy");
        _sellAndCheck(1_000_000 ether);
    }

    /// @notice One 0.1 ETH buy happened. A sale larger than the pool's ETH can absorb is filled only in
    /// part, but the burn is 1% of the whole request.
    function test_saleLargerThanThePoolsEthBurnsOnePercentOfTheRequest() public {
        vm.prank(buyer);
        uint256 bought = router.buyExactIn{value: 0.1 ether}(key, 0);
        assertGt(bought, 0);
        assertLe(bought * 4, token.balanceOf(holder), "the holder can cover the request");
        _sellAndCheck(bought * 4);
    }
}

// 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} from "v4-core/src/types/PoolOperation.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {BMCToken} from "src/BMCToken.sol";
import {BMCHook, BMC_HOOK_FLAGS} from "src/BMCHook.sol";
import {BMCSwapRouter} from "src/BMCSwapRouter.sol";
import {HookDeployer} from "src/HookDeployer.sol";

/// @dev Stands in for the community wallet once its EIP-7702 delegate rejects plain ETH.
contract RejectsEth {
    receive() external payable {
        revert("no ETH");
    }
}

/// @notice BMCHook._takeEthFee pushes the buy fee to the immutable recipient with poolManager.take inside
/// the swap whenever the manager's ETH balance covers it, and only mints a claim when the balance is short.
/// The brief's recipient 0x8302...41B0 carries EIP-7702 delegation code on mainnet, so its holder can at any
/// time point it at code that reverts on receiving ETH. From then on every buy on the pool reverts, and
/// collect() reverts too. Expected: the buy completes and the fee is kept as an ERC-6909 claim.
contract RecipientRejectsEthTest is Test {
    address constant COMMUNITY_WALLET = 0x83027AD9d0D5374335086c539dADD1db983441B0;
    uint160 constant OPENING_SQRT_PRICE = uint160(10_000) << 96;

    PoolManager manager;
    BMCToken token;
    BMCHook hook;
    BMCSwapRouter router;
    PoolKey key;
    address buyer = makeAddr("buyer");

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new BMCToken();
        router = new BMCSwapRouter(IPoolManager(address(manager)));
        PoolModifyLiquidityTest lp = new PoolModifyLiquidityTest(IPoolManager(address(manager)));
        bytes memory code = abi.encodePacked(
            type(BMCHook).creationCode,
            abi.encode(address(manager), address(token), COMMUNITY_WALLET, uint256(100), uint256(100))
        );
        hook = BMCHook(HookDeployer.deploy(code, BMC_HOOK_FLAGS));
        key = PoolKey(CurrencyLibrary.ADDRESS_ZERO, Currency.wrap(address(token)), 12_500, 60, IHooks(address(hook)));
        manager.initialize(key, OPENING_SQRT_PRICE);
        token.approve(address(lp), type(uint256).max);
        vm.deal(address(this), 2 ether);
        // Full-range liquidity: the manager holds ~1.1 ETH, so the hook takes the direct-pay branch.
        lp.modifyLiquidity{value: 1.1 ether}(key, ModifyLiquidityParams(-887_220, 887_220, 1e22, 0), "");
        // The wallet's delegate now rejects ETH.
        vm.etch(COMMUNITY_WALLET, address(new RejectsEth()).code);
        vm.deal(buyer, 1 ether);
    }

    function test_buyStillCompletesWhenTheWalletRejectsEth() public {
        vm.prank(buyer);
        uint256 out = router.buyExactIn{value: 0.1 ether}(key, 0);
        assertGt(out, 0, "the buy should go through");
        assertEq(hook.pendingEthFees(), 0.001 ether, "the fee should be kept as a claim for later redemption");
    }

    function test_exactOutputBuyStillCompletesWhenTheWalletRejectsEth() public {
        vm.prank(buyer);
        uint256 ethIn = router.buyExactOut{value: 1 ether}(key, 1_000_000 ether);
        assertGt(ethIn, 0, "the buy should go through");
        assertGt(hook.pendingEthFees(), 0, "the fee should be kept as a claim for later redemption");
    }
}