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

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

contract NativeReserveBoundaryTest is Test, IUnlockCallback {
    using TransientStateLibrary for IPoolManager;

    address constant RECIPIENT = 0x047F606fD5b2BaA5f5C6c4aB8958E45CB6B054B7;
    IPoolManager manager;
    TaxyHook hook;
    TaxyToken token;
    PoolKey key;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new TaxyToken();
        bytes memory creation = abi.encodePacked(type(TaxyHook).creationCode, abi.encode(manager));
        bytes32 hash = keccak256(creation);
        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 ((uint160(predicted) & Hooks.ALL_HOOK_MASK) != 0x20cc) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(at != address(0), "deployment failed");
            hook = TaxyHook(at);
            break;
        }
        require(address(hook) != address(0), "salt not found");
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, TickMath.getSqrtPriceAtTick(600));
        vm.deal(address(this), 10 ether);
        // At the upper tick, this valid position requires token1 only.
        manager.unlock(abi.encode(uint8(0), int256(0), false));
        assertEq(address(manager).balance, 0);
        assertGt(token.balanceOf(address(manager)), 0);
    }

    function test_validBuyAtTokenOnlyBoundary() public {
        uint256 recipientBefore = RECIPIENT.balance;
        uint256 tokenBefore = token.balanceOf(address(this));
        uint256 ethBefore = address(this).balance;
        // Ordinary v4 ordering: swap, then settle the returned input debt.
        BalanceDelta delta = abi.decode(manager.unlock(abi.encode(uint8(1), -int256(1 ether), false)), (BalanceDelta));
        assertEq(int256(delta.amount0()), -int256(1 ether));
        assertGt(token.balanceOf(address(this)), tokenBefore);
        assertEq(ethBefore - address(this).balance, 1 ether);
        assertEq(RECIPIENT.balance - recipientBefore, 0.04 ether);
        assertEq(address(manager).balance, 0.96 ether);
        assertEq(manager.getNonzeroDeltaCount(), 0);
    }

    function test_controlSameBuyWithNativePreSettlement() public {
        uint256 recipientBefore = RECIPIENT.balance;
        uint256 tokenBefore = token.balanceOf(address(this));
        BalanceDelta delta = abi.decode(manager.unlock(abi.encode(uint8(1), -int256(1 ether), true)), (BalanceDelta));
        assertEq(int256(delta.amount0()), -int256(1 ether));
        assertGt(token.balanceOf(address(this)), tokenBefore);
        assertEq(RECIPIENT.balance - recipientBefore, 0.04 ether);
        assertEq(address(manager).balance, 0.96 ether);
        assertEq(manager.getNonzeroDeltaCount(), 0);
    }

    function test_tokenExactOutputAtTokenOnlyBoundary() public {
        uint256 recipientBefore = RECIPIENT.balance;
        BalanceDelta delta = abi.decode(manager.unlock(abi.encode(uint8(1), int256(1 ether), false)), (BalanceDelta));
        assertEq(int256(delta.amount1()), int256(1 ether));
        assertEq(RECIPIENT.balance - recipientBefore, uint256(-int256(delta.amount0())) / 25);
        assertEq(manager.getNonzeroDeltaCount(), 0);
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (uint8 action, int256 amount, bool preSettle) = abi.decode(data, (uint8, int256, bool));
        BalanceDelta delta;
        if (action == 0) {
            (delta,) = manager.modifyLiquidity(key, ModifyLiquidityParams(-600, 600, 1000 ether, bytes32(0)), "");
        } else {
            if (preSettle) {
                manager.sync(key.currency0);
                manager.settle{value: 1 ether}();
            }
            delta = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
        }
        _settle(key.currency0);
        _settle(key.currency1);
        return abi.encode(delta);
    }

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

    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 {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {TaxyHook} from "src/TaxyHook.sol";
import {TaxyToken} from "src/TaxyToken.sol";

/// @dev Minimal router using the ordinary v4 flow: manager.swap first, then settle the trader's
/// debts. The project's own test router (test/helpers/SettlementRouter.sol) settles in the same order.
contract PlainRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function addLiquidity(PoolKey memory key, ModifyLiquidityParams memory p) external payable {
        manager.unlock(abi.encode(true, key, p, SwapParams(false, 0, 0), msg.sender));
        if (address(this).balance > 0) payable(msg.sender).transfer(address(this).balance);
    }

    function swap(PoolKey memory key, SwapParams memory p) external payable returns (BalanceDelta d) {
        d = abi.decode(
            manager.unlock(abi.encode(false, key, ModifyLiquidityParams(0, 0, 0, 0), p, msg.sender)), (BalanceDelta)
        );
        if (address(this).balance > 0) payable(msg.sender).transfer(address(this).balance);
    }

    function unlockCallback(bytes calldata raw) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool isLiq, PoolKey memory key, ModifyLiquidityParams memory lp, SwapParams memory sp, address payer) =
            abi.decode(raw, (bool, PoolKey, ModifyLiquidityParams, SwapParams, address));
        BalanceDelta d;
        if (isLiq) (d,) = manager.modifyLiquidity(key, lp, "");
        else d = manager.swap(key, sp, "");
        _settle(key.currency0, payer, d.amount0());
        _settle(key.currency1, payer, d.amount1());
        return abi.encode(d);
    }

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

    receive() external payable {}
}

/// @notice Finding: afterSwap pays the 4% fee with PoolManager.take BEFORE the buyer's ETH is settled,
/// so a fee-bearing buy needs the PoolManager to already hold >= fee wei of native ETH from somewhere.
/// A launch pool seeded single-sided (tokens only, the usual shape for a token launch) deposits no
/// ETH, so on a PoolManager that holds no ETH every buy reverts with NativeTransferFailed inside take.
contract ManagerEthShortfallTest is Test {
    address constant RECIPIENT = 0x047F606fD5b2BaA5f5C6c4aB8958E45CB6B054B7;
    uint160 constant ONE = 79228162514264337593543950336;

    IPoolManager manager;
    TaxyHook hook;
    TaxyToken token;
    PlainRouter router;
    PoolKey key;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new TaxyToken();
        hook = _deployHook();
        router = new PlainRouter(manager);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, ONE);
        token.approve(address(router), type(uint256).max);
        // Launch-style seed: the position sits entirely below the current tick, so it holds only t4.
        router.addLiquidity(key, ModifyLiquidityParams(-600, -60, 1_000_000 ether, bytes32(0)));
        assertEq(address(manager).balance, 0, "a token-only seed leaves the PoolManager with no ETH");
        vm.deal(address(this), 100 ether);
    }

    /// @dev Expected: a solvent buyer paying 1 ETH exact input gets tokens and the recipient gets 0.04 ETH.
    /// Actual on current code: PoolManager.take(ETH, recipient, 0.04e18) in afterSwap fails with
    /// OutOfFunds -> NativeTransferFailed, wrapped as HookCallFailed, and the whole swap reverts.
    function test_firstBuyerCannotBuyWhenManagerHoldsNoEth() public {
        uint256 feeBefore = RECIPIENT.balance;
        BalanceDelta d = router.swap{value: 1 ether}(key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(int256(d.amount0()), -1 ether, "buyer pays exactly 1 ETH");
        assertGt(d.amount1(), 0, "buyer receives tokens");
        assertEq(RECIPIENT.balance - feeBefore, 0.04 ether, "recipient receives the 4% fee");
    }

    function _deployHook() internal returns (TaxyHook) {
        bytes memory creation = abi.encodePacked(type(TaxyHook).creationCode, abi.encode(manager));
        bytes32 h = keccak256(creation);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, h)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != 0x20cc) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(at != address(0), "create2 failed");
            return TaxyHook(at);
        }
        revert("no salt");
    }

    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 {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {TaxyHook} from "src/TaxyHook.sol";
import {TaxyToken} from "src/TaxyToken.sol";

/// @dev Ordinary v4 router: call manager.swap first, then settle the trader's debts. This is the
/// order every standard router (and the project's own test/helpers/SettlementRouter.sol) uses.
contract OrdinaryRouter is IUnlockCallback {
    IPoolManager immutable manager;

    constructor(IPoolManager m) {
        manager = m;
    }

    function modifyLiquidity(PoolKey memory key, ModifyLiquidityParams memory p) external payable {
        manager.unlock(abi.encode(true, key, p, SwapParams(false, 0, 0), msg.sender));
        if (address(this).balance > 0) payable(msg.sender).transfer(address(this).balance);
    }

    function swap(PoolKey memory key, SwapParams memory p) external payable returns (BalanceDelta d) {
        d = abi.decode(
            manager.unlock(abi.encode(false, key, ModifyLiquidityParams(0, 0, 0, 0), p, msg.sender)), (BalanceDelta)
        );
        if (address(this).balance > 0) payable(msg.sender).transfer(address(this).balance);
    }

    function unlockCallback(bytes calldata raw) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool isLiq, PoolKey memory key, ModifyLiquidityParams memory lp, SwapParams memory sp, address payer) =
            abi.decode(raw, (bool, PoolKey, ModifyLiquidityParams, SwapParams, address));
        BalanceDelta d;
        if (isLiq) (d,) = manager.modifyLiquidity(key, lp, "");
        else d = manager.swap(key, sp, "");
        _settle(key.currency0, payer, d.amount0());
        _settle(key.currency1, payer, d.amount1());
        return abi.encode(d);
    }

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

    receive() external payable {}
}

/// @notice TaxyHook.afterSwap pays the fee with PoolManager.take BEFORE the buyer's ETH input is
/// settled, so the transfer is funded from whatever native ETH the PoolManager already holds. When
/// the manager holds less than the fee (fresh manager, token-only seeded launch pool), every
/// fee-bearing buy reverts with NativeTransferFailed wrapped in HookCallFailed.
/// Expected: a solvent buyer's swap executes and the recipient is credited the 4% fee in ETH
/// (either delivered directly or as a native ERC-6909 claim, whichever the fix chooses).
contract JudgeManagerShortfallTest is Test {
    address constant RECIPIENT = 0x047F606fD5b2BaA5f5C6c4aB8958E45CB6B054B7;
    uint160 constant ONE = 79228162514264337593543950336;

    IPoolManager manager;
    TaxyHook hook;
    TaxyToken token;
    OrdinaryRouter router;
    PoolKey key;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        token = new TaxyToken();
        hook = _deployHook();
        router = new OrdinaryRouter(manager);
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(hook)));
        manager.initialize(key, ONE);
        token.approve(address(router), type(uint256).max);
        // Launch-style seed: a position entirely below the current tick holds only currency1 (t4).
        router.modifyLiquidity(key, ModifyLiquidityParams(-600, -60, 1_000_000 ether, bytes32(0)));
        assertEq(address(manager).balance, 0, "token-only seed leaves the manager with no ETH");
        vm.deal(address(this), 100 ether);
    }

    function _recipientCredit() internal view returns (uint256) {
        return RECIPIENT.balance + manager.balanceOf(RECIPIENT, 0);
    }

    function test_exactInputBuyExecutesWhenManagerHoldsNoEth() public {
        uint256 creditBefore = _recipientCredit();
        BalanceDelta d = router.swap{value: 1 ether}(key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(int256(d.amount0()), -1 ether, "buyer pays exactly 1 ETH");
        assertGt(d.amount1(), 0, "buyer receives tokens");
        assertEq(_recipientCredit() - creditBefore, 0.04 ether, "recipient is credited the 4% fee in ETH");
    }

    function test_exactOutputBuyExecutesWhenManagerHoldsNoEth() public {
        uint256 creditBefore = _recipientCredit();
        BalanceDelta d = router.swap{value: 10 ether}(key, SwapParams(true, 1 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(int256(d.amount1()), 1 ether, "buyer receives exactly 1 t4");
        assertLt(d.amount0(), 0, "buyer pays ETH");
        assertGt(_recipientCredit() - creditBefore, 0, "recipient is credited the fee");
    }

    /// @dev Control: identical swap once the manager holds ETH from an unrelated position.
    function test_controlBuyWorksOnceManagerHoldsEth() public {
        router.modifyLiquidity{value: 10 ether}(key, ModifyLiquidityParams(-600, 600, 100 ether, bytes32(0)));
        assertGt(address(manager).balance, 0);
        uint256 creditBefore = _recipientCredit();
        router.swap{value: 1 ether}(key, SwapParams(true, -1 ether, TickMath.MIN_SQRT_PRICE + 1));
        assertEq(_recipientCredit() - creditBefore, 0.04 ether);
    }

    function _deployHook() internal returns (TaxyHook) {
        bytes memory creation = abi.encodePacked(type(TaxyHook).creationCode, abi.encode(manager));
        bytes32 h = keccak256(creation);
        for (uint256 i; i < 200_000; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, h)))));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK != 0x20cc) continue;
            address at;
            assembly ("memory-safe") {
                at := create2(0, add(creation, 32), mload(creation), salt)
            }
            require(at != address(0), "create2 failed");
            return TaxyHook(at);
        }
        revert("no salt");
    }

    receive() external payable {}
}