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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev The taxed venue. Like UniswapV2Pair.swap, the caller names who receives the output.
contract TaxedVenue {
    function swap(OneMDollar token, uint256 amountOut, address to) external {
        token.transfer(to, amountOut);
    }
}

/// @dev An ordinary, unprivileged trader that routes the taxed venue's tokens through the exempt
/// PoolManager using only its public unlock / sync / settle / take surface.
contract Relay is IUnlockCallback {
    IPoolManager internal immutable manager;
    OneMDollar internal immutable token;
    TaxedVenue internal immutable venue;

    constructor(IPoolManager manager_, OneMDollar token_, TaxedVenue venue_) {
        manager = manager_;
        token = token_;
        venue = venue_;
    }

    /// Buy side: venue -> manager (exempt) -> relay (exempt).
    function buy(uint256 amount) external {
        manager.unlock(abi.encode(true, amount));
    }

    /// Sell side: relay -> manager (exempt) -> venue (exempt).
    function sell(uint256 amount) external {
        manager.unlock(abi.encode(false, amount));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool isBuy, uint256 amount) = abi.decode(data, (bool, uint256));
        Currency c = Currency.wrap(address(token));
        manager.sync(c);
        if (isBuy) {
            venue.swap(token, amount, address(manager));
        } else {
            token.transfer(address(manager), amount);
        }
        uint256 credited = manager.settle();
        manager.take(c, isBuy ? address(this) : address(venue), credited);
        return "";
    }
}

contract PoolManagerRelayBypassTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    TaxedVenue internal venue;
    Relay internal relay;
    address internal constant TREASURY = address(0x1002);
    uint256 internal constant AMOUNT = 100 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        venue = new TaxedVenue();
        token = new OneMDollar(address(venue), TREASURY, address(manager));
        relay = new Relay(manager, token, venue);
        // Fund the venue through the taxed path: 10,000 in, 1% (100) lands in the venue.
        token.transfer(address(venue), 10_000 ether);
        assertEq(token.balanceOf(address(venue)), AMOUNT);
        assertEq(token.balanceOf(TREASURY), 9_900 ether);
    }

    /// A buyer taking 100 1MD out of the taxed venue should net at most 1 1MD; the treasury 99.
    function test_buyFromTaxedPoolThroughManagerPaysNoTax() public {
        uint256 treasuryBefore = token.balanceOf(TREASURY);
        relay.buy(AMOUNT);
        assertLe(token.balanceOf(address(relay)), AMOUNT / 100, "buyer kept more than the 1% net of a taxed buy");
        assertEq(token.balanceOf(TREASURY) - treasuryBefore, AMOUNT - AMOUNT / 100, "treasury did not receive the 99% fee");
    }

    /// A seller putting 100 1MD into the taxed venue should deliver at most 1 1MD; the treasury 99.
    function test_sellIntoTaxedPoolThroughManagerPaysNoTax() public {
        token.transfer(address(relay), AMOUNT); // ordinary wallet transfer, untaxed by design
        uint256 venueBefore = token.balanceOf(address(venue));
        uint256 treasuryBefore = token.balanceOf(TREASURY);
        relay.sell(AMOUNT);
        assertLe(token.balanceOf(address(venue)) - venueBefore, AMOUNT / 100, "venue received more than the 1% net of a taxed sell");
        assertEq(token.balanceOf(TREASURY) - treasuryBefore, AMOUNT - AMOUNT / 100, "treasury did not receive the 99% fee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Stands in for the configured taxed pool: a venue that, like a Uniswap v2/v3 pair or any
/// router, delivers bought tokens to a recipient the trader names.
contract TaxedVenue {
    OneMDollar public token;

    function init(OneMDollar token_) external {
        require(address(token) == address(0), "set");
        token = token_;
    }

    /// @notice Sells `amount` 1MD to `to` for native currency at a fixed price.
    function buy(address to, uint256 amount) external payable {
        require(msg.value >= amount / 1_000_000, "underpaid");
        require(token.transfer(to, amount), "transfer failed");
    }
}

/// @dev An ordinary trader that uses the exempt PoolManager as a pass-through: no pool, no swap,
/// only sync / settle / take. Every token leg touching the taxed venue has the manager as the other
/// endpoint, so the token's `_update` never charges the 99% fee.
contract Bypasser is IUnlockCallback {
    IPoolManager internal immutable manager;
    OneMDollar internal immutable token;
    TaxedVenue internal immutable venue;

    constructor(IPoolManager manager_, OneMDollar token_, TaxedVenue venue_) {
        manager = manager_;
        token = token_;
        venue = venue_;
    }

    receive() external payable {}

    /// @notice Sell `amount` into the taxed venue without paying the fee.
    function sellUntaxed(uint256 amount) external {
        manager.unlock(abi.encode(true, amount));
    }

    /// @notice Buy `amount` from the taxed venue without paying the fee.
    function buyUntaxed(uint256 amount) external {
        manager.unlock(abi.encode(false, amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool sell, uint256 amount) = abi.decode(data, (bool, uint256));
        Currency c = Currency.wrap(address(token));
        if (sell) {
            // trader -> manager (exempt), manager -> venue (exempt): the venue receives 100%.
            manager.sync(c);
            token.transfer(address(manager), amount);
            uint256 paid = manager.settle();
            manager.take(c, address(venue), paid);
        } else {
            // venue -> manager (exempt), manager -> trader (exempt): the trader receives 100%.
            manager.sync(c);
            venue.buy{value: amount / 1_000_000}(address(manager), amount);
            uint256 paid = manager.settle();
            manager.take(c, address(this), paid);
        }
        return "";
    }
}

contract TaxBypassViaManagerTest is Test {
    uint256 internal constant SUPPLY = 1_000_000_000 ether;
    address internal constant TREASURY = address(0x1002);

    PoolManager internal manager;
    TaxedVenue internal venue;
    OneMDollar internal token;
    Bypasser internal trader;

    function setUp() public {
        manager = new PoolManager(address(this));
        venue = new TaxedVenue();
        token = new OneMDollar(address(venue), TREASURY, address(manager));
        venue.init(token);
        trader = new Bypasser(manager, token, venue);
        vm.deal(address(trader), 10 ether);
    }

    /// @dev Expected: selling 1,000 1MD into the taxed pool pays 990 1MD to the treasury and
    /// delivers 10 1MD to the pool. Actual on this code: the pool receives all 1,000 and the
    /// treasury receives nothing, because both legs have the exempt PoolManager as an endpoint.
    function test_sellIntoTaxedPoolThroughManagerPaysNoFee() public {
        uint256 amount = 1_000 ether;
        token.transfer(address(trader), amount);

        trader.sellUntaxed(amount);

        uint256 expectedFee = (amount * token.TAX_BPS()) / token.BPS_DENOMINATOR();
        assertEq(token.balanceOf(address(trader)), 0, "trader kept tokens");
        assertEq(token.balanceOf(address(manager)), 0, "manager kept tokens");
        assertEq(token.balanceOf(TREASURY), expectedFee, "the 99% sell tax was not collected");
        assertEq(token.balanceOf(address(venue)), amount - expectedFee, "the pool received more than the net amount");
    }

    /// @dev Expected: buying 1,000 1MD from the taxed pool pays 990 1MD to the treasury and
    /// delivers 10 1MD to the buyer. Actual on this code: the buyer receives all 1,000 and the
    /// treasury receives nothing.
    function test_buyFromTaxedPoolThroughManagerPaysNoFee() public {
        uint256 amount = 1_000 ether;
        // Stock the venue the way any LP would, by an ordinary (taxed) transfer; then measure only the buy.
        token.transfer(address(venue), 1_000_000 ether);
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        trader.buyUntaxed(amount);

        uint256 expectedFee = (amount * token.TAX_BPS()) / token.BPS_DENOMINATOR();
        assertEq(token.balanceOf(address(manager)), 0, "manager kept tokens");
        assertEq(token.balanceOf(TREASURY) - treasuryBefore, expectedFee, "the 99% buy tax was not collected");
        assertEq(token.balanceOf(address(trader)), amount - expectedFee, "the buyer received more than the net amount");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Stands at the taxed `liquidityPool` address. It only forwards what it holds, like any venue.
contract PoolStub {
    function push(OneMDollar token, address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev An ordinary trader. Routes a transfer through the exempt PoolManager instead of sending directly.
contract Conduit is IUnlockCallback {
    IPoolManager internal immutable manager;
    OneMDollar internal immutable token;

    constructor(IPoolManager manager_, OneMDollar token_) {
        manager = manager_;
        token = token_;
    }

    /// Sell path: my tokens -> PoolManager (exempt: to == poolManager) -> taxed pool (exempt: from == poolManager).
    function sellThroughManager(address pool, uint256 amount) external {
        manager.unlock(abi.encode(true, pool, amount));
    }

    /// Buy path: taxed pool -> PoolManager (exempt: to == poolManager) -> me (exempt: from == poolManager).
    function buyThroughManager(PoolStub pool, uint256 amount) external {
        manager.unlock(abi.encode(false, address(pool), amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool sell, address pool, uint256 amount) = abi.decode(data, (bool, address, uint256));
        Currency currency = Currency.wrap(address(token));
        manager.sync(currency);
        if (sell) {
            token.transfer(address(manager), amount);
        } else {
            PoolStub(pool).push(token, address(manager), amount);
        }
        manager.settle();
        manager.take(currency, sell ? pool : address(this), amount);
        return "";
    }
}

contract PoolManagerBypassTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    PoolStub internal pool;
    Conduit internal trader;
    address internal constant TREASURY = address(0x1002);

    function setUp() public {
        manager = new PoolManager(address(this));
        pool = new PoolStub();
        token = new OneMDollar(address(pool), TREASURY, address(manager));
        trader = new Conduit(manager, token);
    }

    /// A sale of 100 1MD into the taxed pool must leave 99 1MD with the treasury and 1 1MD in the pool,
    /// whichever path the tokens take. Routed through the PoolManager, the pool receives all 100 and
    /// the treasury nothing.
    function test_sellIntoTaxedPoolThroughPoolManagerPaysTax() public {
        token.transfer(address(trader), 100 ether);
        trader.sellThroughManager(address(pool), 100 ether);
        assertEq(token.balanceOf(address(trader)), 0, "trader kept tokens");
        assertEq(token.balanceOf(TREASURY), 99 ether, "treasury did not receive the 99% fee");
        assertEq(token.balanceOf(address(pool)), 1 ether, "pool received more than the 1% net");
    }

    /// 100 1MD leaving the taxed pool must deliver at most 1 1MD to the buyer. Routed through the
    /// PoolManager, the buyer receives all 100 and the treasury nothing.
    function test_buyFromTaxedPoolThroughPoolManagerPaysTax() public {
        // Fund the pool directly in storage so the setup itself is untaxed on any version of the token.
        deal(address(token), address(pool), 100 ether);
        assertEq(token.balanceOf(address(pool)), 100 ether);

        // Once fixed, the routed buy either reverts (the manager was shorted) or delivers the taxed net.
        try trader.buyThroughManager(pool, 100 ether) {} catch {}
        assertLe(token.balanceOf(address(trader)), 1 ether, "buyer received more than the 1% net");
        assertEq(
            token.balanceOf(address(pool)) + token.balanceOf(TREASURY) + token.balanceOf(address(trader))
                + token.balanceOf(address(manager)),
            100 ether,
            "conservation"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Seeds the launch pool and trades at it exactly as the factory and an ordinary trader do.
contract V4Participant is IUnlockCallback {
    IPoolManager internal immutable manager;
    address internal immutable controller = msg.sender;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function seed(PoolKey calldata key, bool tokenIsZero) external {
        require(msg.sender == controller, "controller only");
        manager.unlock(abi.encode(true, key, tokenIsZero, int256(10_000 ether)));
    }

    function swap(PoolKey calldata key, bool zeroForOne, int256 amount) external returns (BalanceDelta) {
        require(msg.sender == controller, "controller only");
        return abi.decode(manager.unlock(abi.encode(false, key, zeroForOne, amount)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool isSeed, PoolKey memory key, bool direction, int256 amount) =
            abi.decode(data, (bool, PoolKey, bool, int256));
        BalanceDelta delta;
        if (isSeed) {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(
                    direction ? int24(0) : int24(-600), direction ? int24(600) : int24(0), amount, bytes32(0)
                ),
                ""
            );
        } else {
            uint160 limit = direction ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
            delta = manager.swap(key, SwapParams(direction, amount, limit), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            uint256 amount = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) {
                manager.settle{value: amount}();
            } else {
                manager.sync(currency);
                OneMDollar(Currency.unwrap(currency)).transfer(address(manager), amount);
                manager.settle();
            }
        } else if (delta > 0) {
            manager.take(currency, address(this), uint256(int256(delta)));
        }
    }
}

/// @dev The brief asks for a 99% fee on the liquidity pool. The launch has exactly one pool: the
/// Uniswap v4 pool inside the PoolManager. A buy at that pool must pay the fee to the treasury.
contract LaunchPoolUntaxedTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    V4Participant internal factory;
    address internal constant OTHER_POOL = address(0x1001);
    address internal constant TREASURY = address(0x1002);

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new V4Participant(manager);
        vm.prank(address(factory));
        token = new OneMDollar(OTHER_POOL, TREASURY, address(manager));
        assertEq(token.balanceOf(address(factory)), token.totalSupply(), "factory holds the supply");
    }

    function test_buyAtTheLaunchPoolPaysThePoolTax() public {
        bool tokenIsZero = address(token) < address(0);
        PoolKey memory key = PoolKey(
            Currency.wrap(tokenIsZero ? address(token) : address(0)),
            Currency.wrap(tokenIsZero ? address(0) : address(token)),
            3000,
            60,
            IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.seed(key, tokenIsZero);
        assertGt(token.balanceOf(address(manager)), 0, "seed arrived");

        V4Participant trader = new V4Participant(manager);
        vm.deal(address(trader), 1 ether);
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        // Buy: 0.01 ETH exact input, 1MD out of the launch pool to the trader.
        BalanceDelta delta = trader.swap(key, !tokenIsZero, -0.01 ether);
        int128 tokenDelta = tokenIsZero ? delta.amount0() : delta.amount1();
        assertGt(tokenDelta, 0, "swap produced tokens");
        uint256 gross = uint256(int256(tokenDelta));
        uint256 fee = (gross * token.TAX_BPS()) / token.BPS_DENOMINATOR();
        assertGt(fee, 0, "fee is material");

        assertEq(token.balanceOf(address(trader)), gross - fee, "buyer should receive the 1% net");
        assertEq(token.balanceOf(TREASURY) - treasuryBefore, fee, "treasury should receive the 99% pool fee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Stands in for the configured taxable venue. Like a Uniswap v2 pair's
/// swap(amount0Out, amount1Out, to, data), it delivers its token output to whatever
/// address the caller names. Nothing else about the venue matters for this test.
contract TaxedVenue {
    OneMDollar internal immutable token;

    constructor(OneMDollar token_) {
        token = token_;
    }

    function swapOut(address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev An ordinary trader that uses the exempt launch PoolManager as a pass-through:
/// sync -> move tokens in -> settle -> take to the final recipient.
contract PassThroughTrader is IUnlockCallback {
    IPoolManager internal immutable manager;
    OneMDollar internal immutable token;
    TaxedVenue internal immutable venue;

    constructor(IPoolManager manager_, OneMDollar token_, TaxedVenue venue_) {
        manager = manager_;
        token = token_;
        venue = venue_;
    }

    /// Sell `amount` into the taxed venue without paying the pool tax.
    function sellViaManager(uint256 amount) external {
        manager.unlock(abi.encode(true, amount));
    }

    /// Buy `amount` out of the taxed venue without paying the pool tax.
    function buyViaManager(uint256 amount) external {
        manager.unlock(abi.encode(false, amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool sell, uint256 amount) = abi.decode(data, (bool, uint256));
        Currency currency = Currency.wrap(address(token));
        manager.sync(currency);
        if (sell) {
            // wallet -> manager: an ordinary transfer, untaxed by design.
            token.transfer(address(manager), amount);
        } else {
            // venue -> manager: taxable endpoint, but the manager leg is exempt.
            venue.swapOut(address(manager), amount);
        }
        uint256 paid = manager.settle();
        // manager -> venue (sell) or manager -> trader (buy): the manager leg is exempt again.
        manager.take(currency, sell ? address(venue) : address(this), paid);
        return "";
    }
}

contract PoolManagerPassThroughTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    TaxedVenue internal venue;
    PassThroughTrader internal trader;
    address internal constant TREASURY = address(0x1002);

    function setUp() public {
        manager = new PoolManager(address(this));
        address predictedVenue = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
        token = new OneMDollar(predictedVenue, TREASURY, address(manager));
        venue = new TaxedVenue(token);
        assertEq(address(venue), predictedVenue, "venue prediction");
        trader = new PassThroughTrader(manager, token, venue);
    }

    /// A sale of 100 1MD into the taxed venue must deliver 1 1MD to the venue and 99 1MD to the
    /// treasury. Routed wallet -> manager -> venue, the venue receives all 100 and the treasury 0.
    function test_sellThroughManagerStillPaysPoolTax() public {
        token.transfer(address(trader), 100 ether);
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        trader.sellViaManager(100 ether);

        assertEq(token.balanceOf(address(trader)), 0, "trader kept tokens");
        assertLe(token.balanceOf(address(venue)), 1 ether, "venue should receive at most the 1% net");
        assertGe(token.balanceOf(TREASURY) - treasuryBefore, 99 ether, "treasury should receive at least the 99% fee");
    }

    /// A purchase of 100 1MD out of the taxed venue must deliver 1 1MD to the buyer and 99 1MD to
    /// the treasury. Routed venue -> manager -> buyer, the buyer receives all 100 and the treasury 0.
    function test_buyThroughManagerStillPaysPoolTax() public {
        // Fund the venue with 100 1MD. This wallet -> venue leg is taxed in every version of the
        // token (10,000 in, 100 arrive), so the fixture is identical before and after a fix.
        token.transfer(address(venue), 10_000 ether);
        assertEq(token.balanceOf(address(venue)), 100 ether, "venue fixture");
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        trader.buyViaManager(100 ether);

        assertEq(token.balanceOf(address(venue)), 0, "venue should have paid out");
        assertLe(token.balanceOf(address(trader)), 1 ether, "buyer should receive at most the 1% net");
        assertGe(token.balanceOf(TREASURY) - treasuryBefore, 99 ether, "treasury should receive at least the 99% fee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Stands in for the configured taxable venue. Like a Uniswap v2 pair's
/// swap(amount0Out, amount1Out, to, data), it delivers its token output to whatever
/// address the caller names. Nothing else about the venue matters for this test.
contract TaxedVenue {
    OneMDollar internal immutable token;

    constructor(OneMDollar token_) {
        token = token_;
    }

    function swapOut(address to, uint256 amount) external {
        token.transfer(to, amount);
    }
}

/// @dev An ordinary trader that uses the exempt launch PoolManager as a pass-through:
/// sync -> move tokens in -> settle -> take to the final recipient.
contract PassThroughTrader is IUnlockCallback {
    IPoolManager internal immutable manager;
    OneMDollar internal immutable token;
    TaxedVenue internal immutable venue;

    constructor(IPoolManager manager_, OneMDollar token_, TaxedVenue venue_) {
        manager = manager_;
        token = token_;
        venue = venue_;
    }

    /// Sell `amount` into the taxed venue without paying the pool tax.
    function sellViaManager(uint256 amount) external {
        manager.unlock(abi.encode(true, amount));
    }

    /// Buy `amount` out of the taxed venue without paying the pool tax.
    function buyViaManager(uint256 amount) external {
        manager.unlock(abi.encode(false, amount));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool sell, uint256 amount) = abi.decode(data, (bool, uint256));
        Currency currency = Currency.wrap(address(token));
        manager.sync(currency);
        if (sell) {
            // wallet -> manager: an ordinary transfer, untaxed by design.
            token.transfer(address(manager), amount);
        } else {
            // venue -> manager: taxable endpoint, but the manager leg is exempt.
            venue.swapOut(address(manager), amount);
        }
        uint256 paid = manager.settle();
        // manager -> venue (sell) or manager -> trader (buy): the manager leg is exempt again.
        manager.take(currency, sell ? address(venue) : address(this), paid);
        return "";
    }
}

contract PoolManagerPassThroughTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    TaxedVenue internal venue;
    PassThroughTrader internal trader;
    address internal constant TREASURY = address(0x1002);

    function setUp() public {
        manager = new PoolManager(address(this));
        address predictedVenue = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 1);
        token = new OneMDollar(predictedVenue, TREASURY, address(manager));
        venue = new TaxedVenue(token);
        assertEq(address(venue), predictedVenue, "venue prediction");
        trader = new PassThroughTrader(manager, token, venue);
    }

    /// A sale of 100 1MD into the taxed venue must deliver 1 1MD to the venue and 99 1MD to the
    /// treasury. Routed wallet -> manager -> venue, the venue receives all 100 and the treasury 0.
    function test_sellThroughManagerStillPaysPoolTax() public {
        token.transfer(address(trader), 100 ether);
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        trader.sellViaManager(100 ether);

        assertEq(token.balanceOf(address(trader)), 0, "trader kept tokens");
        assertLe(token.balanceOf(address(venue)), 1 ether, "venue should receive at most the 1% net");
        assertGe(token.balanceOf(TREASURY) - treasuryBefore, 99 ether, "treasury should receive at least the 99% fee");
    }

    /// A purchase of 100 1MD out of the taxed venue must deliver 1 1MD to the buyer and 99 1MD to
    /// the treasury. Routed venue -> manager -> buyer, the buyer receives all 100 and the treasury 0.
    function test_buyThroughManagerStillPaysPoolTax() public {
        // Fund the venue with 100 1MD. This wallet -> venue leg is taxed in every version of the
        // token (10,000 in, 100 arrive), so the fixture is identical before and after a fix.
        token.transfer(address(venue), 10_000 ether);
        assertEq(token.balanceOf(address(venue)), 100 ether, "venue fixture");
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        trader.buyViaManager(100 ether);

        assertEq(token.balanceOf(address(venue)), 0, "venue should have paid out");
        assertLe(token.balanceOf(address(trader)), 1 ether, "buyer should receive at most the 1% net");
        assertGe(token.balanceOf(TREASURY) - treasuryBefore, 99 ether, "treasury should receive at least the 99% fee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Seeds the launch pool and trades at it exactly as the factory and an ordinary trader do.
contract V4Participant is IUnlockCallback {
    IPoolManager internal immutable manager;
    address internal immutable controller = msg.sender;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function seed(PoolKey calldata key, bool tokenIsZero) external {
        require(msg.sender == controller, "controller only");
        manager.unlock(abi.encode(true, key, tokenIsZero, int256(10_000 ether)));
    }

    function swap(PoolKey calldata key, bool zeroForOne, int256 amount) external returns (BalanceDelta) {
        require(msg.sender == controller, "controller only");
        return abi.decode(manager.unlock(abi.encode(false, key, zeroForOne, amount)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool isSeed, PoolKey memory key, bool direction, int256 amount) =
            abi.decode(data, (bool, PoolKey, bool, int256));
        BalanceDelta delta;
        if (isSeed) {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(
                    direction ? int24(0) : int24(-600), direction ? int24(600) : int24(0), amount, bytes32(0)
                ),
                ""
            );
        } else {
            uint160 limit = direction ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
            delta = manager.swap(key, SwapParams(direction, amount, limit), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            uint256 amount = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) {
                manager.settle{value: amount}();
            } else {
                manager.sync(currency);
                OneMDollar(Currency.unwrap(currency)).transfer(address(manager), amount);
                manager.settle();
            }
        } else if (delta > 0) {
            manager.take(currency, address(this), uint256(int256(delta)));
        }
    }
}

/// @dev The brief asks for a 99% fee on the liquidity pool. The launch has exactly one pool: the
/// Uniswap v4 pool inside the PoolManager. A buy at that pool must pay the fee to the treasury.
contract LaunchPoolUntaxedTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    V4Participant internal factory;
    address internal constant OTHER_POOL = address(0x1001);
    address internal constant TREASURY = address(0x1002);

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new V4Participant(manager);
        vm.prank(address(factory));
        token = new OneMDollar(OTHER_POOL, TREASURY, address(manager));
        assertEq(token.balanceOf(address(factory)), token.totalSupply(), "factory holds the supply");
    }

    function test_buyAtTheLaunchPoolPaysThePoolTax() public {
        bool tokenIsZero = address(token) < address(0);
        PoolKey memory key = PoolKey(
            Currency.wrap(tokenIsZero ? address(token) : address(0)),
            Currency.wrap(tokenIsZero ? address(0) : address(token)),
            3000,
            60,
            IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.seed(key, tokenIsZero);
        assertGt(token.balanceOf(address(manager)), 0, "seed arrived");

        V4Participant trader = new V4Participant(manager);
        vm.deal(address(trader), 1 ether);
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        // Buy: 0.01 ETH exact input, 1MD out of the launch pool to the trader.
        BalanceDelta delta = trader.swap(key, !tokenIsZero, -0.01 ether);
        int128 tokenDelta = tokenIsZero ? delta.amount0() : delta.amount1();
        assertGt(tokenDelta, 0, "swap produced tokens");
        uint256 gross = uint256(int256(tokenDelta));
        uint256 fee = (gross * token.TAX_BPS()) / token.BPS_DENOMINATOR();
        assertGt(fee, 0, "fee is material");

        assertEq(token.balanceOf(address(trader)), gross - fee, "buyer should receive the 1% net");
        assertEq(token.balanceOf(TREASURY) - treasuryBefore, fee, "treasury should receive the 99% pool fee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {OneMDollar} from "src/OneMDollar.sol";

/// @dev Seeds the launch pool and trades at it exactly as the factory and an ordinary trader do.
contract V4Participant is IUnlockCallback {
    IPoolManager internal immutable manager;
    address internal immutable controller = msg.sender;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function seed(PoolKey calldata key, bool tokenIsZero) external {
        require(msg.sender == controller, "controller only");
        manager.unlock(abi.encode(true, key, tokenIsZero, int256(10_000 ether)));
    }

    function swap(PoolKey calldata key, bool zeroForOne, int256 amount) external returns (BalanceDelta) {
        require(msg.sender == controller, "controller only");
        return abi.decode(manager.unlock(abi.encode(false, key, zeroForOne, amount)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external override returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool isSeed, PoolKey memory key, bool direction, int256 amount) =
            abi.decode(data, (bool, PoolKey, bool, int256));
        BalanceDelta delta;
        if (isSeed) {
            (delta,) = manager.modifyLiquidity(
                key,
                ModifyLiquidityParams(
                    direction ? int24(0) : int24(-600), direction ? int24(600) : int24(0), amount, bytes32(0)
                ),
                ""
            );
        } else {
            uint160 limit = direction ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1;
            delta = manager.swap(key, SwapParams(direction, amount, limit), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 delta) private {
        if (delta < 0) {
            uint256 amount = uint256(-int256(delta));
            if (Currency.unwrap(currency) == address(0)) {
                manager.settle{value: amount}();
            } else {
                manager.sync(currency);
                OneMDollar(Currency.unwrap(currency)).transfer(address(manager), amount);
                manager.settle();
            }
        } else if (delta > 0) {
            manager.take(currency, address(this), uint256(int256(delta)));
        }
    }
}

/// @dev The brief asks for a 99% fee on the liquidity pool. The launch has exactly one pool: the
/// Uniswap v4 pool inside the PoolManager. A buy at that pool must pay the fee to the treasury.
contract LaunchPoolUntaxedTest is Test {
    PoolManager internal manager;
    OneMDollar internal token;
    V4Participant internal factory;
    address internal constant OTHER_POOL = address(0x1001);
    address internal constant TREASURY = address(0x1002);

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new V4Participant(manager);
        vm.prank(address(factory));
        token = new OneMDollar(OTHER_POOL, TREASURY, address(manager));
        assertEq(token.balanceOf(address(factory)), token.totalSupply(), "factory holds the supply");
    }

    function test_buyAtTheLaunchPoolPaysThePoolTax() public {
        bool tokenIsZero = address(token) < address(0);
        PoolKey memory key = PoolKey(
            Currency.wrap(tokenIsZero ? address(token) : address(0)),
            Currency.wrap(tokenIsZero ? address(0) : address(token)),
            3000,
            60,
            IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.seed(key, tokenIsZero);
        assertGt(token.balanceOf(address(manager)), 0, "seed arrived");

        V4Participant trader = new V4Participant(manager);
        vm.deal(address(trader), 1 ether);
        uint256 treasuryBefore = token.balanceOf(TREASURY);

        // Buy: 0.01 ETH exact input, 1MD out of the launch pool to the trader.
        BalanceDelta delta = trader.swap(key, !tokenIsZero, -0.01 ether);
        int128 tokenDelta = tokenIsZero ? delta.amount0() : delta.amount1();
        assertGt(tokenDelta, 0, "swap produced tokens");
        uint256 gross = uint256(int256(tokenDelta));
        uint256 fee = (gross * token.TAX_BPS()) / token.BPS_DENOMINATOR();
        assertGt(fee, 0, "fee is material");

        assertEq(token.balanceOf(address(trader)), gross - fee, "buyer should receive the 1% net");
        assertEq(token.balanceOf(TREASURY) - treasuryBefore, fee, "treasury should receive the 99% pool fee");
    }
}