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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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";

/// @dev Deploys the token (so it holds the supply like the factory) and seeds the pool.
contract Seeder is IUnlockCallback {
    IPoolManager immutable manager;
    IMDOLAR public token;
    PoolKey key;

    constructor(IPoolManager m) {
        manager = m;
        token = new IMDOLAR(address(m));
    }

    function seed(PoolKey memory k, int24 lower, int24 upper, int256 liquidity) external {
        key = k;
        manager.unlock(abi.encode(ModifyLiquidityParams(lower, upper, liquidity, bytes32(0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (BalanceDelta d,) = manager.modifyLiquidity(key, abi.decode(data, (ModifyLiquidityParams)), "");
        // ETH side is zero for a single-sided token seed below the price; pay the token side.
        uint256 owed = uint256(-int256(d.amount1()));
        manager.sync(key.currency1);
        token.transfer(address(manager), owed);
        manager.settle();
        return "";
    }
}

/// @dev An ordinary trader that buys DOLAR with ETH but keeps the purchase inside the manager as an
/// ERC-6909 claim instead of calling take(). Later it sells by burning the claim. The token contract
/// never sees a transfer whose `from` is the manager, so the 99% buy tax is never charged.
contract ClaimTrader is IUnlockCallback {
    IPoolManager immutable manager;
    PoolKey key;
    uint8 mode; // 1 = buy into claims, 2 = sell from claims, 3 = buy+sell in one unlock

    constructor(IPoolManager m) {
        manager = m;
    }

    receive() external payable {}

    function run(PoolKey memory k, uint8 mode_, int256 amount) external returns (uint256 tokenOut) {
        key = k;
        mode = mode_;
        return abi.decode(manager.unlock(abi.encode(amount)), (uint256));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        int256 amount = abi.decode(data, (int256));
        Currency dolar = key.currency1;
        uint256 id = uint256(uint160(Currency.unwrap(dolar)));
        if (mode == 1) {
            // ETH in, DOLAR out. Keep DOLAR as an ERC-6909 claim: no ERC-20 transfer happens.
            BalanceDelta d = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
            manager.settle{value: uint256(-int256(d.amount0()))}();
            uint256 got = uint256(uint128(d.amount1()));
            manager.mint(address(this), id, got);
            return abi.encode(got);
        } else if (mode == 2) {
            // DOLAR in (paid by burning the claim), ETH out.
            BalanceDelta d = manager.swap(key, SwapParams(false, amount, TickMath.MAX_SQRT_PRICE - 1), "");
            manager.burn(address(this), id, uint256(-int256(d.amount1())));
            manager.take(key.currency0, address(this), uint256(uint128(d.amount0())));
            return abi.encode(0);
        } else {
            // Buy then sell the whole purchase inside one unlock: DOLAR delta nets to zero.
            BalanceDelta buy = manager.swap(key, SwapParams(true, amount, TickMath.MIN_SQRT_PRICE + 1), "");
            uint256 got = uint256(uint128(buy.amount1()));
            BalanceDelta sell = manager.swap(key, SwapParams(false, -int256(got), TickMath.MAX_SQRT_PRICE - 1), "");
            int256 eth = int256(buy.amount0()) + int256(sell.amount0());
            if (eth < 0) manager.settle{value: uint256(-eth)}();
            else if (eth > 0) manager.take(key.currency0, address(this), uint256(eth));
            return abi.encode(got);
        }
    }
}

contract UntaxedClaimBuyTest is Test {
    PoolManager manager;
    Seeder seeder;
    IMDOLAR token;
    ClaimTrader trader;
    PoolKey key;
    uint256 constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        seeder = new Seeder(manager);
        token = seeder.token();
        key = PoolKey(Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0)));
        manager.initialize(key, uint160(1 << 96));
        seeder.seed(key, -600, 0, 100_000_000 ether);
        trader = new ClaimTrader(manager);
        vm.deal(address(trader), 10 ether);
    }

    /// A trader buys DOLAR from the launch pool, holds it as an ERC-6909 claim, and sells it back.
    /// Expected under "99% tax on all buys, no exceptions": at most 1% of the purchase survives, so
    /// the trader can sell back at most gross/100 and the supply shrinks by 99% of gross.
    /// Actual: the whole gross purchase is kept and sold back; totalSupply never changes.
    function test_buyHeldAsClaimPaysNoTax() public {
        uint256 gross = trader.run(key, 1, -0.01 ether);
        assertGt(gross, 0, "no purchase");
        uint256 id = uint256(uint160(address(token)));
        assertEq(manager.balanceOf(address(trader), id), gross, "claim is the full gross purchase");

        // Sell back the entire gross purchase. With a 99% buy tax this must be impossible: a taxed
        // buyer would only own gross/100.
        uint256 ethBefore = address(trader).balance;
        trader.run(key, 2, -int256(gross));
        assertGt(address(trader).balance, ethBefore, "sell paid nothing");

        // The tax should have burned 99% of gross. It burned nothing.
        assertEq(token.totalSupply(), SUPPLY - (gross - gross / 100), "99% buy tax was not charged");
    }

    /// Same bypass without claims: buy and sell inside one unlock so no DOLAR ever leaves the manager.
    function test_buyAndSellInOneUnlockPaysNoTax() public {
        uint256 gross = trader.run(key, 3, -0.01 ether);
        assertGt(gross, 0, "no purchase");
        assertEq(token.totalSupply(), SUPPLY - (gross - gross / 100), "99% buy tax was not charged");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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";

/// @dev Factory stand-in: deploys the token (so it holds the supply) and seeds the pool.
contract Seeder is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function seed(PoolKey memory key_, int24 lower, int24 upper, int256 liquidity) external {
        key = key_;
        manager.unlock(abi.encode(lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (int24 lower, int24 upper, int256 liquidity) = abi.decode(data, (int24, int24, int256));
        (BalanceDelta delta,) =
            manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liquidity, bytes32(0)), "");
        if (delta.amount1() < 0) {
            uint256 owed = uint256(uint128(-delta.amount1()));
            manager.sync(key.currency1);
            require(IMDOLAR(Currency.unwrap(key.currency1)).transfer(address(manager), owed));
            manager.settle();
        }
        if (delta.amount0() < 0) {
            manager.settle{value: uint256(uint128(-delta.amount0()))}();
        }
        return "";
    }
}

/// @dev An ordinary trader that settles its DOLAR side in ERC-6909 claims instead of ERC-20 takes.
contract ClaimTrader is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function buyIntoClaims(PoolKey memory key_, int256 ethIn) external returns (BalanceDelta) {
        key = key_;
        return abi.decode(manager.unlock(abi.encode(true, ethIn)), (BalanceDelta));
    }

    function sellFromClaims(PoolKey memory key_, int256 tokenIn) external returns (BalanceDelta) {
        key = key_;
        return abi.decode(manager.unlock(abi.encode(false, tokenIn)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool buy, int256 amount) = abi.decode(data, (bool, int256));
        uint256 tokenId = uint256(uint160(Currency.unwrap(key.currency1)));
        BalanceDelta delta = manager.swap(
            key,
            SwapParams(buy, amount, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            ""
        );
        if (buy) {
            // Pay ETH, receive DOLAR as claim tokens: no ERC-20 transfer from the manager.
            manager.settle{value: uint256(uint128(-delta.amount0()))}();
            manager.mint(address(this), tokenId, uint256(uint128(delta.amount1())));
        } else {
            // Pay DOLAR by burning claims, receive ETH.
            manager.burn(address(this), tokenId, uint256(uint128(-delta.amount1())));
            manager.take(key.currency0, address(this), uint256(uint128(delta.amount0())));
        }
        return abi.encode(delta);
    }
}

contract ClaimBypassTest is Test {
    PoolManager internal manager;
    Seeder internal factory;
    ClaimTrader internal trader;
    IMDOLAR internal token;
    PoolKey internal key;
    uint256 internal constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new Seeder(manager);
        trader = new ClaimTrader(manager);
        token = factory.deployToken();
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.seed(key, -600, 0, 100_000_000 ether);
        vm.deal(address(trader), 10 ether);
    }

    /// @dev A buy whose output is settled as ERC-6909 claims pays no tax, and the claims can be
    /// sold straight back into the pool for ETH. The 99% buy tax is bypassed end to end.
    function test_claimSettledBuyAndSellPayNoTax() public {
        uint256 supplyBefore = token.totalSupply();
        uint256 ethBefore = address(trader).balance;
        uint256 tokenId = uint256(uint160(address(token)));

        BalanceDelta buy = trader.buyIntoClaims(key, -0.01 ether);
        uint256 gross = uint256(uint128(buy.amount1()));
        assertGt(gross, 0, "buy produced no DOLAR");
        emit log_named_uint("gross DOLAR out", gross);
        emit log_named_uint("eth before", ethBefore);
        // The trader holds the whole gross output as claims and no ERC-20 balance.
        assertEq(manager.balanceOf(address(trader), tokenId), gross, "claims not minted");
        assertEq(token.balanceOf(address(trader)), 0);

        // Sell the entire gross back for ETH.
        trader.sellFromClaims(key, -int256(gross));
        assertEq(manager.balanceOf(address(trader), tokenId), 0, "claims not burned");

        // Round trip lost only the LP fee (0.3% each way), not 99%.
        uint256 ethAfter = address(trader).balance;
        emit log_named_uint("eth after", ethAfter);
        assertGt(ethAfter, ethBefore - 0.0001 ether, "round trip lost far more than the LP fee");

        // The guarantee the token is supposed to enforce: a buy burns 99% of the gross output.
        // On the current code nothing was burned at all.
        assertEq(token.totalSupply(), supplyBefore - (gross - gross / 100), "no tax was burned on a claim-settled buy");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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";

/// @dev Stands in for the launch factory: deploys the token (so it holds the supply) and seeds the pool.
contract Seeder is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function seed(PoolKey memory key_, int24 lower, int24 upper, int256 liquidity) external {
        key = key_;
        manager.unlock(abi.encode(ModifyLiquidityParams(lower, upper, liquidity, bytes32(0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (BalanceDelta delta,) =
            manager.modifyLiquidity(key, abi.decode(data, (ModifyLiquidityParams)), "");
        if (delta.amount0() < 0) {
            manager.settle{value: uint256(-int256(delta.amount0()))}();
        }
        if (delta.amount1() < 0) {
            uint256 owed = uint256(-int256(delta.amount1()));
            manager.sync(key.currency1);
            require(IMDOLAR(Currency.unwrap(key.currency1)).transfer(address(manager), owed));
            manager.settle();
        }
        return "";
    }
}

/// @dev An ordinary trader that settles its DOLAR output as ERC-6909 claims (PoolManager.mint)
/// instead of withdrawing ERC-20 (PoolManager.take), and later pays a sell with those claims
/// (PoolManager.burn). Neither path calls the token contract.
contract ClaimTrader is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    /// @param zeroForOne true = pay ETH (currency0), receive DOLAR (currency1)
    function swapWithClaims(PoolKey memory key_, bool zeroForOne, int256 amountSpecified)
        external
        returns (BalanceDelta)
    {
        key = key_;
        return abi.decode(manager.unlock(abi.encode(zeroForOne, amountSpecified)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool zeroForOne, int256 amountSpecified) = abi.decode(data, (bool, int256));
        BalanceDelta delta = manager.swap(
            key,
            SwapParams(
                zeroForOne,
                amountSpecified,
                zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
            ),
            ""
        );
        // currency0 is native ETH.
        if (delta.amount0() < 0) {
            manager.settle{value: uint256(-int256(delta.amount0()))}();
        } else if (delta.amount0() > 0) {
            manager.take(key.currency0, address(this), uint256(uint128(delta.amount0())));
        }
        // currency1 is DOLAR: positive delta is minted as a claim, negative delta is paid by burning claims.
        uint256 id = key.currency1.toId();
        if (delta.amount1() > 0) {
            manager.mint(address(this), id, uint256(uint128(delta.amount1())));
        } else if (delta.amount1() < 0) {
            manager.burn(address(this), id, uint256(-int256(delta.amount1())));
        }
        return abi.encode(delta);
    }
}

contract ClaimSettledBuyBypassesTaxTest is Test {
    PoolManager internal manager;
    Seeder internal factory;
    ClaimTrader internal trader;
    IMDOLAR internal token;
    PoolKey internal key;
    uint256 internal constant SUPPLY = 1_000_000_000 ether;
    int256 internal constant LIQUIDITY = 100_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new Seeder(manager);
        token = factory.deployToken();
        assertEq(token.balanceOf(address(factory)), SUPPLY);
        // DOLAR address is nonzero so native ETH is currency0 and DOLAR is currency1.
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        // Single-sided DOLAR seed: currency1 liquidity sits just below the current price.
        factory.seed(key, -600, 0, LIQUIDITY);
        trader = new ClaimTrader(manager);
        vm.deal(address(trader), 10 ether);
    }

    /// @dev The requested rule: every buy from the configured pool pays a 99% tax. A buy whose
    /// output is settled as an ERC-6909 claim inside the PoolManager pays nothing: the trader is
    /// credited the full gross output and no DOLAR is burned.
    function test_ClaimSettledBuyPaysNoTax() public {
        uint256 id = Currency.wrap(address(token)).toId();
        uint256 managerBefore = token.balanceOf(address(manager));
        uint256 supplyBefore = token.totalSupply();

        BalanceDelta delta = trader.swapWithClaims(key, true, -0.01 ether);
        uint256 gross = uint256(uint128(delta.amount1()));
        assertGt(gross, 0, "the swap produced no DOLAR");

        uint256 claims = manager.balanceOf(address(trader), id);
        uint256 erc20 = token.balanceOf(address(trader));
        // What the pool gave up: ERC-20 that left the manager plus claims credited against it.
        uint256 poolGaveUp = managerBefore - token.balanceOf(address(manager)) + claims;
        assertEq(poolGaveUp, gross, "accounting sanity");

        // Requirement: the buyer keeps at most 1% of what the pool gave up and 99% is burned.
        assertLe(claims + erc20, poolGaveUp / 100, "buyer received more than 1%: tax bypassed");
        assertGe(
            supplyBefore - token.totalSupply(),
            poolGaveUp - poolGaveUp / 100,
            "99% of the bought DOLAR was not burned"
        );
    }

    /// @dev A complete untaxed round trip: buy with ETH into claims, sell the claims back for ETH.
    /// The token's supply never changes, so the 99% buy tax never applied to this trading cycle.
    function test_ClaimRoundTripNeverTouchesTheTax() public {
        uint256 id = Currency.wrap(address(token)).toId();
        uint256 supplyBefore = token.totalSupply();
        uint256 ethBefore = address(trader).balance;

        BalanceDelta buy = trader.swapWithClaims(key, true, -0.01 ether);
        uint256 gross = uint256(uint128(buy.amount1()));
        assertEq(manager.balanceOf(address(trader), id), gross, "claim equals full gross output");

        trader.swapWithClaims(key, false, -int256(gross));
        assertEq(manager.balanceOf(address(trader), id), 0, "claims fully spent on the sell");
        // The trader got ETH back (minus the 0.3% pool fee each way), never holding any taxed DOLAR.
        assertGt(address(trader).balance, ethBefore - 0.01 ether, "no ETH returned");

        // Requirement: a buy of `gross` DOLAR burns 99% of it. Nothing was burned.
        assertGe(
            supplyBefore - token.totalSupply(), gross - gross / 100, "no DOLAR was burned on the buy"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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} from "v4-core/src/types/PoolOperation.sol";

/// @dev A liquidity provider on the launch pool. Adds and removes liquidity the way the standard
/// v4 periphery does: pays debts with settle, withdraws credits with take (an ERC-20 transfer).
contract LiquidityProvider is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function modify(PoolKey memory key_, int24 lower, int24 upper, int256 liquidity)
        external
        returns (BalanceDelta delta)
    {
        key = key_;
        delta = abi.decode(
            manager.unlock(abi.encode(ModifyLiquidityParams(lower, upper, liquidity, bytes32(0)))),
            (BalanceDelta)
        );
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (BalanceDelta delta,) =
            manager.modifyLiquidity(key, abi.decode(data, (ModifyLiquidityParams)), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

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

contract LiquidityWithdrawalLosesPrincipalTest is Test {
    PoolManager internal manager;
    LiquidityProvider internal factory;
    LiquidityProvider internal lp;
    IMDOLAR internal token;
    PoolKey internal key;
    uint256 internal constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new LiquidityProvider(manager);
        token = factory.deployToken();
        assertEq(token.balanceOf(address(factory)), SUPPLY);
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        // The launch seed: single-sided DOLAR (currency1) just below the current price.
        factory.modify(key, -600, 0, 100_000_000 ether);

        // A third-party LP acquires DOLAR through an ordinary (untaxed) wallet transfer, e.g. a
        // contributor claim or an OTC purchase from the requester's remainder.
        lp = new LiquidityProvider(manager);
        vm.prank(address(factory));
        require(token.transfer(address(lp), 1_000 ether));
        vm.deal(address(lp), 10 ether);
    }

    /// @dev Adding and immediately removing liquidity is not a buy. The LP must get its DOLAR
    /// principal back (less at most 1 wei of rounding per side). Instead 99% of it is burned.
    function test_RemovingLiquidityReturnsThePrincipal() public {
        uint256 dolarBefore = token.balanceOf(address(lp));
        uint256 supplyBefore = token.totalSupply();

        // In-range position straddling the current price, so both ETH and DOLAR are deposited.
        BalanceDelta added = lp.modify(key, -600, 600, 10 ether);
        uint256 deposited = uint256(-int256(added.amount1()));
        assertGt(deposited, 0, "no DOLAR was deposited");
        assertEq(token.balanceOf(address(lp)), dolarBefore - deposited, "deposit arrived short");

        // Remove the whole position in the same state: no swaps happened in between.
        BalanceDelta removed = lp.modify(key, -600, 600, -10 ether);
        uint256 owed = uint256(uint128(removed.amount1()));
        assertGe(owed + 1, deposited, "the pool owes the LP its principal back");

        uint256 returned = token.balanceOf(address(lp)) - (dolarBefore - deposited);
        assertGe(returned + 1, deposited, "liquidity withdrawal lost DOLAR principal");
        assertEq(token.totalSupply(), supplyBefore, "removing liquidity burned supply");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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";

/// @dev Stands in for the launch factory: deploys the token so it holds the supply, then seeds the
/// pool single-sided in DOLAR exactly as the launch does.
contract Seeder is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function seed(PoolKey memory key_, int256 liquidity) external {
        key = key_;
        manager.unlock(abi.encode(liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        int256 liquidity = abi.decode(data, (int256));
        (BalanceDelta delta,) =
            manager.modifyLiquidity(key, ModifyLiquidityParams(-600, 0, liquidity, bytes32(0)), "");
        uint256 owed = uint256(-int256(delta.amount1()));
        manager.sync(key.currency1);
        require(IMDOLAR(Currency.unwrap(key.currency1)).transfer(address(manager), owed));
        require(manager.settle() == owed, "settle short");
        return "";
    }
}

/// @dev An unprivileged trader. Mode 0: buy ETH->DOLAR and keep the output as an ERC-6909 claim.
/// Mode 1: pay a DOLAR->ETH sell by burning claims. Mode 2: buy then sell inside one unlock so the
/// DOLAR delta nets to zero. None of these paths makes an ERC-20 transfer out of the manager.
contract ClaimTrader is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function run(PoolKey memory key_, uint8 mode, uint256 amount) external returns (uint256 gross) {
        key = key_;
        return abi.decode(manager.unlock(abi.encode(mode, amount)), (uint256));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (uint8 mode, uint256 amount) = abi.decode(data, (uint8, uint256));
        uint256 id = key.currency1.toId();
        uint256 gross;
        if (mode == 0) {
            BalanceDelta d = manager.swap(
                key, SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1), ""
            );
            manager.settle{value: uint256(uint128(-d.amount0()))}();
            gross = uint256(uint128(d.amount1()));
            manager.mint(address(this), id, gross);
        } else if (mode == 1) {
            manager.burn(address(this), id, amount);
            BalanceDelta d = manager.swap(
                key, SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1), ""
            );
            require(uint256(uint128(-d.amount1())) == amount, "partial fill");
            manager.take(key.currency0, address(this), uint256(uint128(d.amount0())));
            gross = amount;
        } else {
            BalanceDelta buy = manager.swap(
                key, SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1), ""
            );
            gross = uint256(uint128(buy.amount1()));
            BalanceDelta sell = manager.swap(
                key, SwapParams(false, -int256(gross), TickMath.MAX_SQRT_PRICE - 1), ""
            );
            require(uint256(uint128(-sell.amount1())) == gross, "partial fill");
            // The DOLAR deltas cancel; only the ETH difference is settled.
            int256 ethNet = int256(buy.amount0()) + int256(sell.amount0());
            if (ethNet < 0) manager.settle{value: uint256(-ethNet)}();
            else if (ethNet > 0) manager.take(key.currency0, address(this), uint256(ethNet));
        }
        return abi.encode(gross);
    }
}

/// @notice Finding: the 99% buy tax only fires on an ERC-20 transfer whose `from` is the manager.
/// A v4 buy whose output stays inside the manager (ERC-6909 claim, or netted against a sell in the
/// same unlock) never calls the token, so the buyer receives 100% of the gross and nothing burns.
contract ReviewClaimBypassTest is Test {
    PoolManager internal manager;
    Seeder internal factory;
    ClaimTrader internal trader;
    IMDOLAR internal token;
    PoolKey internal key;
    uint256 internal constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new Seeder(manager);
        token = factory.deployToken();
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.seed(key, 100_000_000 ether);
        trader = new ClaimTrader(manager);
        vm.deal(address(trader), 10 ether);
    }

    /// @dev Expected (99% tax on all buys): the buyer holds at most gross/100 of value and
    /// 99% of gross is burned. Actual: the claim is the full gross and totalSupply is unchanged.
    function test_BuySettledAsClaimPaysNoTax() public {
        uint256 gross = trader.run(key, 0, 0.01 ether);
        assertEq(gross, 9_969_999_999_005_990, "fixture drift");
        uint256 claim = manager.balanceOf(address(trader), key.currency1.toId());
        assertLe(claim, gross / 100, "buyer kept more than 1% of a buy");
        assertEq(token.totalSupply(), SUPPLY - (gross - gross / 100), "no tax burned on the buy");
    }

    /// @dev Expected: a buy-then-sell round trip loses ~99% of the ETH. Actual: only the two 0.3%
    /// LP fees are lost and the supply never moves.
    function test_ClaimRoundTripIsUntaxed() public {
        uint256 ethBefore = address(trader).balance;
        uint256 gross = trader.run(key, 0, 0.01 ether);
        trader.run(key, 1, gross);
        assertEq(manager.balanceOf(address(trader), key.currency1.toId()), 0);
        assertEq(token.balanceOf(address(trader)), 0);
        assertLt(address(trader).balance, ethBefore - 0.0098 ether, "round trip was almost free");
        assertEq(token.totalSupply(), SUPPLY - (gross - gross / 100), "no tax burned");
    }

    /// @dev Expected: a buy inside an unlock burns 99% of its output even if resold in the same
    /// unlock. Actual: the DOLAR delta nets to zero, the token is never called, nothing burns.
    function test_SameUnlockBuyAndSellNetsToZeroAndPaysNoTax() public {
        uint256 ethBefore = address(trader).balance;
        uint256 gross = trader.run(key, 2, 0.01 ether);
        assertGt(gross, 0);
        assertLt(address(trader).balance, ethBefore - 0.0098 ether, "round trip was almost free");
        assertEq(token.totalSupply(), SUPPLY - (gross - gross / 100), "no tax burned");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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} from "v4-core/src/types/PoolOperation.sol";

/// @dev A liquidity provider on the launch pool. Adds and removes liquidity the way the standard
/// v4 periphery does: pays debts with settle, withdraws credits with take (an ERC-20 transfer).
contract LiquidityProvider is IUnlockCallback {
    IPoolManager public immutable manager;
    PoolKey private key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function modify(PoolKey memory key_, int24 lower, int24 upper, int256 liquidity)
        external
        returns (BalanceDelta delta)
    {
        key = key_;
        delta = abi.decode(
            manager.unlock(abi.encode(ModifyLiquidityParams(lower, upper, liquidity, bytes32(0)))),
            (BalanceDelta)
        );
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (BalanceDelta delta,) =
            manager.modifyLiquidity(key, abi.decode(data, (ModifyLiquidityParams)), "");
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

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

contract LiquidityWithdrawalLosesPrincipalTest is Test {
    PoolManager internal manager;
    LiquidityProvider internal factory;
    LiquidityProvider internal lp;
    IMDOLAR internal token;
    PoolKey internal key;
    uint256 internal constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new LiquidityProvider(manager);
        token = factory.deployToken();
        assertEq(token.balanceOf(address(factory)), SUPPLY);
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        // The launch seed: single-sided DOLAR (currency1) just below the current price.
        factory.modify(key, -600, 0, 100_000_000 ether);

        // A third-party LP acquires DOLAR through an ordinary (untaxed) wallet transfer, e.g. a
        // contributor claim or an OTC purchase from the requester's remainder.
        lp = new LiquidityProvider(manager);
        vm.prank(address(factory));
        require(token.transfer(address(lp), 1_000 ether));
        vm.deal(address(lp), 10 ether);
    }

    /// @dev Adding and immediately removing liquidity is not a buy. The LP must get its DOLAR
    /// principal back (less at most 1 wei of rounding per side). Instead 99% of it is burned.
    function test_RemovingLiquidityReturnsThePrincipal() public {
        uint256 dolarBefore = token.balanceOf(address(lp));
        uint256 supplyBefore = token.totalSupply();

        // In-range position straddling the current price, so both ETH and DOLAR are deposited.
        BalanceDelta added = lp.modify(key, -600, 600, 10 ether);
        uint256 deposited = uint256(-int256(added.amount1()));
        assertGt(deposited, 0, "no DOLAR was deposited");
        assertEq(token.balanceOf(address(lp)), dolarBefore - deposited, "deposit arrived short");

        // Remove the whole position in the same state: no swaps happened in between.
        BalanceDelta removed = lp.modify(key, -600, 600, -10 ether);
        uint256 owed = uint256(uint128(removed.amount1()));
        assertGe(owed + 1, deposited, "the pool owes the LP its principal back");

        uint256 returned = token.balanceOf(address(lp)) - (dolarBefore - deposited);
        assertGe(returned + 1, deposited, "liquidity withdrawal lost DOLAR principal");
        assertEq(token.totalSupply(), supplyBefore, "removing liquidity burned supply");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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";

/// @dev Stands in for the launch factory: deploys the token so the supply is minted to it and
/// seeds the pool single-sided, exactly as the real factory does.
contract Factory is IUnlockCallback {
    IPoolManager immutable manager;
    PoolKey key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function seed(PoolKey memory key_, int24 lower, int24 upper, int256 liquidity) external {
        key = key_;
        manager.unlock(abi.encode(lower, upper, liquidity));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (int24 lower, int24 upper, int256 liquidity) = abi.decode(data, (int24, int24, int256));
        (BalanceDelta d,) =
            manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liquidity, 0), "");
        require(d.amount0() == 0, "seed must be single sided");
        manager.sync(key.currency1);
        IMDOLAR(Currency.unwrap(key.currency1)).transfer(
            address(manager), uint256(-int256(d.amount1()))
        );
        manager.settle();
        return "";
    }
}

/// @dev An ordinary, unprivileged trader. Nothing here needs a special role: any router can
/// settle a swap output as an ERC-6909 claim or net two swaps inside one unlock.
contract Trader is IUnlockCallback {
    enum Op {
        BuyToClaim,
        SellClaim,
        NettedRoundTrip
    }

    IPoolManager immutable manager;
    PoolKey key;

    constructor(IPoolManager manager_, PoolKey memory key_) {
        manager = manager_;
        key = key_;
    }

    receive() external payable {}

    function run(Op op, uint256 amount) external returns (uint256) {
        return abi.decode(manager.unlock(abi.encode(op, amount)), (uint256));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (Op op, uint256 amount) = abi.decode(data, (Op, uint256));
        uint256 id = key.currency1.toId();
        uint256 result;
        if (op == Op.BuyToClaim) {
            // ETH in, DOLAR output kept inside the manager as a claim: the token is never called.
            BalanceDelta d = manager.swap(
                key, SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1), ""
            );
            manager.settle{value: uint256(uint128(-d.amount0()))}();
            result = uint256(uint128(d.amount1()));
            manager.mint(address(this), id, result);
        } else if (op == Op.SellClaim) {
            // Pay the sell with the claim and take the ETH: again the token is never called.
            manager.burn(address(this), id, amount);
            BalanceDelta d = manager.swap(
                key, SwapParams(false, -int256(amount), TickMath.MAX_SQRT_PRICE - 1), ""
            );
            result = uint256(uint128(d.amount0()));
            manager.take(key.currency0, address(this), result);
        } else {
            // Buy and sell the full gross output inside one unlock: the DOLAR delta nets to zero.
            BalanceDelta bought = manager.swap(
                key, SwapParams(true, -int256(amount), TickMath.MIN_SQRT_PRICE + 1), ""
            );
            uint256 gross = uint256(uint128(bought.amount1()));
            BalanceDelta sold = manager.swap(
                key, SwapParams(false, -int256(gross), TickMath.MAX_SQRT_PRICE - 1), ""
            );
            int256 eth = int256(bought.amount0()) + int256(sold.amount0());
            if (eth < 0) manager.settle{value: uint256(-eth)}();
            else if (eth > 0) manager.take(key.currency0, address(this), uint256(eth));
            result = gross;
        }
        return abi.encode(result);
    }
}

/// @notice Fails on the current token: a buy whose DOLAR output stays inside the PoolManager
/// (ERC-6909 claim, or netted against a sell in the same unlock) pays no tax at all, and the
/// claim can be sold back inside the manager untaxed. The brief is "99% tax on all buys, no
/// exceptions". Passes once buys on the launch pool are taxed where the swap happens.
contract ClaimBuyUntaxedProof is Test {
    PoolManager manager;
    Factory factory;
    IMDOLAR token;
    PoolKey key;
    uint256 constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new Factory(manager);
        token = factory.deployToken();
        assertEq(token.balanceOf(address(factory)), SUPPLY);
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.seed(key, -600, 0, 100_000_000 ether);
    }

    /// @dev Buy 1 ETH of DOLAR into a claim, sell the whole claim back. With a 99% buy tax the
    /// trader can sell back at most 1% of what it bought, so well under 0.02 ETH comes back.
    /// Actual: about 0.994 ETH comes back, the loss being only two 0.3% LP fees.
    function test_ClaimSettledBuyThenSellBackIsTaxed() public {
        Trader trader = new Trader(manager, key);
        vm.deal(address(trader), 1 ether);

        uint256 claim = trader.run(Trader.Op.BuyToClaim, 1 ether);
        assertGt(claim, 0, "the buy produced nothing");
        assertEq(address(trader).balance, 0, "the buy did not spend the ETH");

        uint256 ethBack = trader.run(Trader.Op.SellClaim, claim);
        assertEq(address(trader).balance, ethBack);
        assertLt(
            ethBack,
            0.02 ether,
            "a claim-settled buy was sold back almost whole: the 99% buy tax was never charged"
        );
    }

    /// @dev Buy and sell back inside a single unlock. Same expectation, same actual result.
    function test_NettedRoundTripInsideOneUnlockIsTaxed() public {
        Trader trader = new Trader(manager, key);
        vm.deal(address(trader), 1 ether);

        uint256 gross = trader.run(Trader.Op.NettedRoundTrip, 1 ether);
        assertGt(gross, 0, "the buy produced nothing");

        uint256 ethBack = address(trader).balance;
        assertLt(
            ethBack,
            0.02 ether,
            "a buy netted inside one unlock cost only the LP fee: the 99% buy tax was never charged"
        );
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMDOLAR} from "src/IMDOLAR.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} from "v4-core/src/types/PoolOperation.sol";

/// @dev A v4 account that can deploy the token, hold DOLAR, and add or remove liquidity. The
/// launch factory and an ordinary liquidity provider are both instances of it.
contract LiquidityActor is IUnlockCallback {
    IPoolManager immutable manager;
    PoolKey key;

    constructor(IPoolManager manager_) {
        manager = manager_;
    }

    receive() external payable {}

    function deployToken() external returns (IMDOLAR) {
        return new IMDOLAR(address(manager));
    }

    function move(IMDOLAR token, address to, uint256 amount) external {
        require(token.transfer(to, amount));
    }

    function modify(PoolKey memory key_, int24 lower, int24 upper, int256 liquidity)
        external
        returns (BalanceDelta)
    {
        key = key_;
        return abi.decode(manager.unlock(abi.encode(lower, upper, liquidity)), (BalanceDelta));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager));
        (int24 lower, int24 upper, int256 liquidity) = abi.decode(data, (int24, int24, int256));
        (BalanceDelta d,) =
            manager.modifyLiquidity(key, ModifyLiquidityParams(lower, upper, liquidity, 0), "");
        // ETH side.
        if (d.amount0() < 0) manager.settle{value: uint256(-int256(d.amount0()))}();
        else if (d.amount0() > 0) manager.take(key.currency0, address(this), uint256(uint128(d.amount0())));
        // DOLAR side.
        if (d.amount1() < 0) {
            manager.sync(key.currency1);
            IMDOLAR(Currency.unwrap(key.currency1)).transfer(
                address(manager), uint256(-int256(d.amount1()))
            );
            manager.settle();
        } else if (d.amount1() > 0) {
            manager.take(key.currency1, address(this), uint256(uint128(d.amount1())));
        }
        return abi.encode(d);
    }
}

/// @notice Fails on the current token: a liquidity provider who deposits DOLAR into the launch
/// pool and withdraws it with no trade in between gets 1% of the principal back and 99% is
/// burned, because the token taxes every outgoing transfer from the PoolManager, not only buys.
/// Passes once only buys are taxed.
contract LiquidityWithdrawalTaxedProof is Test {
    PoolManager manager;
    LiquidityActor factory;
    IMDOLAR token;
    PoolKey key;
    uint256 constant SUPPLY = 1_000_000_000 ether;

    function setUp() public {
        manager = new PoolManager(address(this));
        factory = new LiquidityActor(manager);
        token = factory.deployToken();
        key = PoolKey(
            Currency.wrap(address(0)), Currency.wrap(address(token)), 3000, 60, IHooks(address(0))
        );
        manager.initialize(key, uint160(1 << 96));
        factory.modify(key, -600, 0, 100_000_000 ether);
    }

    /// @dev Deposit 1,000 DOLAR worth of two-sided liquidity, withdraw it immediately.
    /// Expected: the pool owes the principal back and the LP receives it, within 1 wei of
    /// rounding, and nothing is burned. Actual: the LP receives owed / 100 and the supply drops
    /// by 99% of the withdrawal.
    function test_LiquidityWithdrawalWithoutATradeReturnsThePrincipal() public {
        LiquidityActor lp = new LiquidityActor(manager);
        factory.move(token, address(lp), 1_000 ether);
        vm.deal(address(lp), 10 ether);

        BalanceDelta added = lp.modify(key, -600, 600, 10 ether);
        uint256 deposited = uint256(-int256(added.amount1()));
        assertGt(deposited, 0, "the deposit took no DOLAR");
        assertEq(token.balanceOf(address(lp)), 1_000 ether - deposited, "deposit arrived short");
        uint256 supplyBefore = token.totalSupply();

        BalanceDelta removed = lp.modify(key, -600, 600, -10 ether);
        uint256 owed = uint256(uint128(removed.amount1()));
        assertGe(owed + 1, deposited, "the pool owes the principal back");

        uint256 received = token.balanceOf(address(lp)) - (1_000 ether - deposited);
        assertGe(
            received + 1,
            owed,
            "a liquidity withdrawal is not a buy, yet the LP received only 1% of its DOLAR principal"
        );
        assertEq(token.totalSupply(), supplyBefore, "a liquidity withdrawal burned supply");
    }
}