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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {BurnTaxHook} from "src/BurnTaxHook.sol";
import {BurnTaxToken} from "src/BurnTaxToken.sol";

/// @dev Minimal router that behaves like production routers (Universal Router / V4Router):
/// it calls `swap` first and settles its debts afterwards, in the same unlock.
contract SettleAfterRouter is IUnlockCallback {
    using TransientStateLibrary for IPoolManager;

    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function modify(PoolKey memory key, ModifyLiquidityParams memory p) external payable returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(msg.sender, key, true, p, SwapParams(false, 0, 0))), (BalanceDelta));
    }

    function swap(PoolKey memory key, SwapParams memory s) external payable returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(msg.sender, key, false, ModifyLiquidityParams(0, 0, 0, 0), s)), (BalanceDelta)
        );
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address payer, PoolKey memory key, bool liq, ModifyLiquidityParams memory p, SwapParams memory s) =
            abi.decode(data, (address, PoolKey, bool, ModifyLiquidityParams, SwapParams));
        BalanceDelta delta;
        if (liq) (delta,) = manager.modifyLiquidity(key, p, "");
        else delta = manager.swap(key, s, "");
        _settle(key.currency0, payer);
        _settle(key.currency1, payer);
        return abi.encode(delta);
    }

    function _settle(Currency c, address payer) private {
        int256 d = manager.currencyDelta(address(this), c);
        if (d < 0) {
            manager.sync(c);
            if (Currency.unwrap(c) == address(0)) {
                manager.settle{value: uint256(-d)}();
            } else {
                require(IERC20(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-d)));
                manager.settle();
            }
        } else if (d > 0) {
            manager.take(c, payer, uint256(d));
        }
    }

    receive() external payable {}
}

contract SellAfterBuyoutTest is Test {
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);

    PoolManager manager;
    SettleAfterRouter router;
    BurnTaxToken token;
    BurnTaxHook hook;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new SettleAfterRouter(manager);
        token = new BurnTaxToken();
        hook = _deployHook();
        // Launch shape: native ETH is currency0, BTAX is currency1, price 1:1.
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1000 ether);
        // Token-only seeding below the current tick: the position holds only BTAX.
        router.modify(key, ModifyLiquidityParams(-120, -60, 1e22, bytes32(0)));
        assertEq(address(manager).balance, 0);
        assertGt(token.balanceOf(address(manager)), 0);
    }

    /// Buys consume the whole BTAX side of the range. Afterwards an ordinary sell through a
    /// settle-after-swap router cannot execute because afterSwap takes the burn from a manager
    /// that holds no BTAX yet. Expected: the sell fills and 1% of the paid BTAX reaches DEAD.
    function test_sellAfterRangeIsBoughtOut() public {
        // Buy with more ETH than the range can absorb: price exits the range, BTAX reserve -> 0.
        router.swap{value: 500 ether}(
            key, SwapParams(true, -500 ether, TickMath.MIN_SQRT_PRICE + 1)
        );
        uint256 reserve = token.balanceOf(address(manager));
        assertLt(reserve, 1e16, "range should be bought out");

        uint256 deadBefore = token.balanceOf(DEAD);
        uint256 myBefore = token.balanceOf(address(this));

        // Ordinary exact-input sell of 1 BTAX. Burn would be 0.01 BTAX, more than the manager holds.
        BalanceDelta d = router.swap(key, SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1));

        assertEq(d.amount1(), -1 ether, "seller pays exactly 1 BTAX");
        assertEq(myBefore - token.balanceOf(address(this)), 1 ether);
        // The 1% must be accounted for: either already at DEAD, or held by the hook as an
        // ERC-6909 claim awaiting redemption to DEAD.
        uint256 burnedNow = token.balanceOf(DEAD) - deadBefore;
        uint256 claimed = manager.balanceOf(address(hook), uint256(uint160(address(token))));
        assertEq(burnedNow + claimed, 0.01 ether, "1% of the paid BTAX is burned or reserved for burning");
    }

    function _deployHook() internal returns (BurnTaxHook deployed) {
        bytes memory code = abi.encodePacked(type(BurnTaxHook).creationCode, abi.encode(manager, address(token)));
        bytes32 h = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), bytes32(i), h)))));
            if ((uint160(predicted) & ((1 << 14) - 1)) == FLAGS) {
                deployed = new BurnTaxHook{salt: bytes32(i)}(manager, address(token));
                return deployed;
            }
        }
        revert("no salt");
    }

    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {BurnTaxHook} from "src/BurnTaxHook.sol";
import {BurnTaxToken} from "src/BurnTaxToken.sol";
import {HookFlags} from "src/HookFlags.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 {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/// @dev Minimal production-shaped router: unlock -> swap -> settle input -> take output.
/// Nothing is paid to the manager before `swap` returns, exactly like Uniswap's own routers.
contract SettleAfterRouter is IUnlockCallback {
    using TransientStateLibrary for IPoolManager;

    IPoolManager public immutable manager;
    address internal payer;

    constructor(IPoolManager m) {
        manager = m;
    }

    function modify(PoolKey memory key, ModifyLiquidityParams memory p) external payable returns (BalanceDelta) {
        payer = msg.sender;
        return abi.decode(manager.unlock(abi.encode(true, key, p, SwapParams(false, 0, 0))), (BalanceDelta));
    }

    function swap(PoolKey memory key, SwapParams memory s) external payable returns (BalanceDelta) {
        payer = msg.sender;
        return abi.decode(
            manager.unlock(abi.encode(false, key, ModifyLiquidityParams(0, 0, 0, bytes32(0)), s)), (BalanceDelta)
        );
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (bool liquidity, PoolKey memory key, ModifyLiquidityParams memory p, SwapParams memory s) =
            abi.decode(data, (bool, PoolKey, ModifyLiquidityParams, SwapParams));
        BalanceDelta delta;
        if (liquidity) (delta,) = manager.modifyLiquidity(key, p, "");
        else delta = manager.swap(key, s, "");
        _settle(key.currency0);
        _settle(key.currency1);
        return abi.encode(delta);
    }

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

    receive() external payable {}
}

contract SellFundingProofTest is Test {
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint160 constant PRICE = 1 << 96;

    PoolManager manager;
    SettleAfterRouter router;
    BurnTaxToken token;
    BurnTaxHook hook;
    PoolKey key;

    receive() external payable {}

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new SettleAfterRouter(manager);
        token = new BurnTaxToken();
        hook = _deployHook();
        // Native ETH is always currency0; BTAX is currency1.
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, PRICE);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1e27);
        // Two-sided launch liquidity: the manager holds BTAX from the start.
        router.modify{value: 1e23}(key, ModifyLiquidityParams(-600, 600, 1e24, bytes32(0)));
        assertGt(token.balanceOf(address(manager)), 1e22);
    }

    /// Buyers take all the BTAX the pool holds, then a holder sells with an ordinary router.
    /// The AMM has the liquidity to take the sell (the same sell on an un-hooked pool fills), but the
    /// hook's `take(BTAX, DEAD, fee)` in afterSwap runs before the router has paid the BTAX in, and the
    /// manager has only dust of BTAX, so the whole swap reverts with ERC20InsufficientBalance.
    function test_sellWithOrdinaryRouterAfterPoolIsBoughtOut() public {
        // Drain: exact-input buy with 1e25 wei ETH, price limit past the range.
        router.swap{value: 1e25}(key, SwapParams(true, -1e25, TickMath.MIN_SQRT_PRICE + 1));
        uint256 managerBtax = token.balanceOf(address(manager));
        assertLt(managerBtax, 1e18, "pool bought out; manager holds dust BTAX");

        uint256 sell = 1e22; // fee = 1e20 > managerBtax
        uint256 traderBefore = token.balanceOf(address(this));
        uint256 deadBefore = token.balanceOf(DEAD);

        // Expected: the sell executes; the trader pays exactly `sell`; 1% is burned (or at least
        // committed as a claim the hook can later burn).
        BalanceDelta d = router.swap(key, SwapParams(false, -int256(sell), TickMath.MAX_SQRT_PRICE - 1));

        assertEq(int256(d.amount1()), -int256(sell), "trader pays exactly the sell amount");
        assertEq(traderBefore - token.balanceOf(address(this)), sell);
        uint256 burnedOrPending =
            token.balanceOf(DEAD) - deadBefore + manager.balanceOf(address(hook), uint160(address(token)));
        assertEq(burnedOrPending, sell / 100, "one percent of the sell is burned or committed to burn");
    }

    function _deployHook() internal returns (BurnTaxHook deployed) {
        bytes memory code = abi.encodePacked(type(BurnTaxHook).creationCode, abi.encode(manager, address(token)));
        bytes32 codeHash = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), salt, codeHash)))));
            if (HookFlags.matches(predicted, HookFlags.BURN_TAX)) {
                deployed = new BurnTaxHook{salt: salt}(manager, address(token));
                require(address(deployed) == predicted);
                return deployed;
            }
        }
        revert("salt search exhausted");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {BurnTaxToken} from "src/BurnTaxToken.sol";
import {BurnTaxHook} from "src/BurnTaxHook.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, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.sol";

contract UnfundedSellProof is Test, IUnlockCallback {
    using TransientStateLibrary for IPoolManager;
    PoolManager manager;
    BurnTaxToken token;
    BurnTaxHook hook;
    PoolKey key;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;

    function setUp() public {
        vm.deal(address(this), 100 ether);
        manager = new PoolManager(address(this));
        token = new BurnTaxToken();
        bytes32 codeHash = keccak256(abi.encodePacked(type(BurnTaxHook).creationCode,
            abi.encode(IPoolManager(address(manager)), address(token))));
        for (uint256 i; i < 200000; ++i) {
            address predicted = address(uint160(uint256(keccak256(
                abi.encodePacked(hex"ff", address(this), bytes32(i), codeHash)))));
            if ((uint160(predicted) & 0x3fff) == 0x20cc) {
                hook = new BurnTaxHook{salt: bytes32(i)}(manager, address(token));
                break;
            }
        }
        require(address(hook) != address(0), "salt search failed");
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, uint160(1 << 96));
        manager.unlock(abi.encode(key, true, int256(0)));
        assertEq(token.balanceOf(address(manager)), 0);
        assertGt(address(manager).balance, 2 ether);
    }

    function test_exactInputSellShouldSettleWithoutPreexistingInputReserves() public {
        _sell(-1 ether);
    }

    function test_exactOutputSellShouldSettleWithoutPreexistingInputReserves() public {
        _sell(1 ether);
    }

    function _sell(int256 amountSpecified) internal {
        // Control: the real manager can execute the same sell without this hook.
        uint256 snapshot = vm.snapshotState();
        PoolKey memory plain = key;
        plain.hooks = IHooks(address(0));
        manager.initialize(plain, uint160(1 << 96));
        manager.unlock(abi.encode(plain, true, int256(0)));
        BalanceDelta control = abi.decode(manager.unlock(abi.encode(plain, false, amountSpecified)), (BalanceDelta));
        assertGt(control.amount0(), 0);
        assertLt(control.amount1(), 0);
        assertTrue(vm.revertToState(snapshot));
        assertEq(token.balanceOf(address(manager)), 0);

        uint256 balanceBefore = token.balanceOf(address(this));
        // Expected: the sell executes, and 1% of the trader's gross BTAX payment
        // reaches DEAD. Actual: afterSwap.take reverts before input can be settled.
        BalanceDelta delta = abi.decode(manager.unlock(abi.encode(key, false, amountSpecified)), (BalanceDelta));
        uint256 paid = balanceBefore - token.balanceOf(address(this));
        assertEq(token.balanceOf(DEAD), paid / 100);
        assertGt(token.balanceOf(DEAD), 0);
        if (amountSpecified < 0) assertEq(delta.amount1(), amountSpecified);
        else assertEq(delta.amount0(), amountSpecified);
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "only manager");
        (PoolKey memory pool, bool adding, int256 amount) = abi.decode(data, (PoolKey, bool, int256));
        BalanceDelta delta;
        if (adding) {
            (delta,) = manager.modifyLiquidity(pool, ModifyLiquidityParams(60, 120, 1e22, bytes32(0)), "");
        } else {
            delta = manager.swap(pool, SwapParams(false, amount, TickMath.MAX_SQRT_PRICE - 1), "");
        }
        // Ordinary flash accounting: settle inputs after swap returns.
        _settle(pool.currency0);
        _settle(pool.currency1);
        return abi.encode(delta);
    }

    function _settle(Currency currency) internal {
        int256 delta = IPoolManager(manager).currencyDelta(address(this), currency);
        if (delta < 0) {
            manager.sync(currency);
            if (Currency.unwrap(currency) == address(0)) manager.settle{value: uint256(-delta)}();
            else {
                token.transfer(address(manager), uint256(-delta));
                manager.settle();
            }
        } else if (delta > 0) manager.take(currency, address(this), uint256(delta));
    }

    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 {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {BurnTaxHook} from "src/BurnTaxHook.sol";
import {BurnTaxToken} from "src/BurnTaxToken.sol";

/// @dev Router shaped like Uniswap's own (V4Router / Universal Router): unlock -> swap -> settle
/// each owed currency afterwards -> take each credited currency. Nothing is paid before `swap` returns.
contract SettleAfterRouter is IUnlockCallback {
    using TransientStateLibrary for IPoolManager;

    IPoolManager public immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function modify(PoolKey memory key, ModifyLiquidityParams memory p) external payable returns (BalanceDelta) {
        return abi.decode(manager.unlock(abi.encode(msg.sender, key, true, p, SwapParams(false, 0, 0))), (BalanceDelta));
    }

    function swap(PoolKey memory key, SwapParams memory s) external payable returns (BalanceDelta) {
        return abi.decode(
            manager.unlock(abi.encode(msg.sender, key, false, ModifyLiquidityParams(0, 0, 0, 0), s)), (BalanceDelta)
        );
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (address payer, PoolKey memory key, bool liq, ModifyLiquidityParams memory p, SwapParams memory s) =
            abi.decode(data, (address, PoolKey, bool, ModifyLiquidityParams, SwapParams));
        BalanceDelta delta;
        if (liq) (delta,) = manager.modifyLiquidity(key, p, "");
        else delta = manager.swap(key, s, "");
        _settle(key.currency0, payer);
        _settle(key.currency1, payer);
        return abi.encode(delta);
    }

    function _settle(Currency c, address payer) private {
        int256 d = manager.currencyDelta(address(this), c);
        if (d < 0) {
            manager.sync(c);
            if (Currency.unwrap(c) == address(0)) {
                manager.settle{value: uint256(-d)}();
            } else {
                require(IERC20(Currency.unwrap(c)).transferFrom(payer, address(manager), uint256(-d)));
                manager.settle();
            }
        } else if (d > 0) {
            manager.take(c, payer, uint256(d));
        }
    }

    receive() external payable {}
}

/// Launch shape: native ETH / BTAX, fee 3000, spacing 60, price 1:1, seeded with BTAX only below
/// the current tick. Buyers take the whole BTAX side of the range; afterwards an ordinary sell
/// through a settle-after-swap router must still execute, with 1% of the BTAX paid going to DEAD
/// (or being committed as an ERC-6909 claim that only DEAD can ever receive).
contract JudgeSellFundingTest is Test {
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    uint160 constant FLAGS = (1 << 13) | (1 << 7) | (1 << 6) | (1 << 3) | (1 << 2);

    PoolManager manager;
    SettleAfterRouter router;
    BurnTaxToken token;
    BurnTaxHook hook;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        router = new SettleAfterRouter(manager);
        token = new BurnTaxToken();
        hook = _deployHook();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, 1 << 96);
        token.approve(address(router), type(uint256).max);
        vm.deal(address(this), 1000 ether);
        router.modify(key, ModifyLiquidityParams(-120, -60, 1e22, bytes32(0)));
        assertEq(address(manager).balance, 0);
        assertGt(token.balanceOf(address(manager)), 1e18);
    }

    function _buyOutRange() internal {
        router.swap{value: 500 ether}(key, SwapParams(true, -500 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertLt(token.balanceOf(address(manager)), 1e16, "range should be bought out");
    }

    function _committedBurn(uint256 deadBefore) internal view returns (uint256) {
        uint256 id = uint256(uint160(address(token)));
        return token.balanceOf(DEAD) - deadBefore + manager.balanceOf(address(hook), id)
            + manager.balanceOf(DEAD, id);
    }

    function test_exactInputSellAfterBuyoutThroughOrdinaryRouter() public {
        _buyOutRange();
        uint256 deadBefore = token.balanceOf(DEAD);
        uint256 myBefore = token.balanceOf(address(this));

        BalanceDelta d = router.swap(key, SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1));

        assertEq(d.amount1(), -1 ether, "seller pays exactly 1 BTAX");
        assertEq(myBefore - token.balanceOf(address(this)), 1 ether);
        assertEq(_committedBurn(deadBefore), 0.01 ether, "1% of the paid BTAX is burned or committed to burn");
    }

    function test_exactOutputSellAfterBuyoutThroughOrdinaryRouter() public {
        _buyOutRange();
        uint256 deadBefore = token.balanceOf(DEAD);
        uint256 myBefore = token.balanceOf(address(this));

        BalanceDelta d = router.swap(key, SwapParams(false, 0.1 ether, TickMath.MAX_SQRT_PRICE - 1));

        assertEq(d.amount0(), 0.1 ether, "buyer of ETH receives exactly the requested ETH");
        uint256 paid = myBefore - token.balanceOf(address(this));
        assertGt(paid, 0);
        assertEq(_committedBurn(deadBefore), paid / 100, "1% of the paid BTAX is burned or committed to burn");
    }

    function _deployHook() internal returns (BurnTaxHook deployed) {
        bytes memory code = abi.encodePacked(type(BurnTaxHook).creationCode, abi.encode(manager, address(token)));
        bytes32 h = keccak256(code);
        for (uint256 i; i < 200_000; ++i) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), bytes32(i), h)))));
            if ((uint160(predicted) & ((1 << 14) - 1)) == FLAGS) {
                deployed = new BurnTaxHook{salt: bytes32(i)}(manager, address(token));
                return deployed;
            }
        }
        revert("no salt");
    }

    receive() external payable {}
}

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

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

contract DeadBalanceProofTest is Test, IUnlockCallback {
    using TransientStateLibrary for IPoolManager;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;
    PoolManager manager;
    BurnTaxToken token;
    BurnTaxHook hook;
    PoolKey key;

    function setUp() public {
        manager = new PoolManager(address(this));
        token = new BurnTaxToken();
        bytes32 initHash =
            keccak256(abi.encodePacked(type(BurnTaxHook).creationCode, abi.encode(manager, address(token))));
        for (uint256 i; i < 200_000; ++i) {
            address predicted = address(
                uint160(
                    uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), initHash)))
                )
            );
            if (uint160(predicted) & 0x3fff != 0x20cc) continue;
            hook = new BurnTaxHook{salt: bytes32(i)}(manager, address(token));
            break;
        }
        require(address(hook) != address(0), "mine hook address");
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook))
        );
        manager.initialize(key, uint160(1 << 96));
        vm.deal(address(this), 100 ether);
        // Above the initial price, this position requires only currency0 (ETH).
        manager.unlock(abi.encode(true));
        assertEq(token.balanceOf(address(manager)), 0);
        assertGt(address(manager).balance, 0);
    }

    function test_successfulSellMustSendOnePercentOfBTAXToDead() public {
        uint256 beforeTrader = token.balanceOf(address(this));
        uint256 beforeDead = token.balanceOf(DEAD);
        BalanceDelta delta = abi.decode(manager.unlock(abi.encode(false)), (BalanceDelta));
        assertEq(beforeTrader - token.balanceOf(address(this)), 1 ether);
        assertEq(delta.amount1(), -1 ether);
        assertGt(delta.amount0(), 0, "sell succeeds and delivers ETH");
        // Assignment: send 1% of the launched-token payment to the dead address.
        // Actual: 0 BTAX arrives; 0.01 ether of ERC-6909 claims is assigned instead.
        assertEq(
            token.balanceOf(DEAD) - beforeDead, 0.01 ether, "successful sell must deliver BTAX tax to DEAD"
        );
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        BalanceDelta delta;
        if (abi.decode(data, (bool))) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(60, 120, 1e22, bytes32(0)), "");
        } else {
            delta = manager.swap(key, SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1), "");
        }
        _settle(key.currency0);
        _settle(key.currency1);
        return abi.encode(delta);
    }

    function _settle(Currency currency) internal {
        int256 debt = IPoolManager(manager).currencyDelta(address(this), currency);
        if (debt > 0) {
            manager.take(currency, address(this), uint256(debt));
        } else if (debt < 0) {
            manager.sync(currency);
            if (Currency.unwrap(currency) == address(0)) {
                manager.settle{value: uint256(-debt)}();
            } else {
                token.transfer(address(manager), uint256(-debt));
                manager.settle();
            }
        }
    }

    receive() external payable {}
}