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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {Kiln} from "src/Kiln.sol";
import {Launcher} from "src/Launcher.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";

/// WETH9-style ERC-20: transfer reverts when the sender's balance is short.
contract ZTO {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "WETH: insufficient");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(balanceOf[from] >= amount, "WETH: insufficient");
        if (from != msg.sender && allowance[from][msg.sender] != type(uint256).max) {
            require(allowance[from][msg.sender] >= amount, "WETH: allowance");
            allowance[from][msg.sender] -= amount;
        }
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract PEPEO is ERC721 {
    constructor() ERC721("P", "P") {}

    function mint(address to, uint256 id) external {
        _mint(to, id);
    }
}

/// Fails on the current Kiln: a ZTO-in swap that core can fill reverts because afterSwap takes
/// real ZTO out of a PoolManager that holds none yet (the trader's ZTO input settles after the
/// swap). Passes once the cut is credited without an immediate transfer (e.g. ERC-6909 claims
/// burned lazily) or otherwise no longer depends on the manager's pre-settlement ZTO balance.
contract TakeLivenessTest is Test {
    ZTO zto;
    PEPEO pepeo;
    IPoolManager manager;
    Launcher launcher;
    Kiln kiln;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest liquidityRouter;
    PoolKey key;
    address trader = makeAddr("trader");

    function _mine(address l, bytes32 h) internal pure returns (bytes32 salt) {
        for (uint256 i;; ++i) {
            salt = bytes32(i);
            address p = address(uint160(uint256(keccak256(bytes.concat(hex"ff", bytes20(l), salt, h)))));
            if (uint160(p) & 0x3fff == 0x00cc) return salt;
        }
    }

    function setUp() public {
        zto = new ZTO();
        pepeo = new PEPEO();
        manager = IPoolManager(address(new PoolManager(address(this))));
        swapRouter = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        uint256[] memory t = new uint256[](4);
        t[1] = 1;
        t[2] = 4;
        t[3] = 21;
        uint24[] memory c = new uint24[](4);
        c[0] = 13000;
        c[1] = 8000;
        c[2] = 3000;
        launcher = new Launcher(address(zto), address(pepeo), address(manager), 60, 2000, t, c, 1500, 50);
        kiln = launcher.open(_mine(address(launcher), launcher.initCodeHash()), 1 << 96);
        key = kiln.poolKey();
        vm.deal(address(this), 1e28);
        zto.mint(trader, 1e24);
        vm.prank(trader);
        zto.approve(address(swapRouter), 1e24);
        // Only ETH-side liquidity exists (range above the current tick is ETH-only), so the
        // PoolManager holds ETH but zero ZTO. This is also the state reached after a ZTO-only
        // launch range has been fully bought out with ETH.
        liquidityRouter.modifyLiquidity{value: 1e25}(
            key, IPoolManager.ModifyLiquidityParams(600, 1200, 1e22, bytes32(0)), ""
        );
        assertEq(zto.balanceOf(address(manager)), 0);
    }

    function test_ztoInSwapSettlesWhenManagerHoldsNoZTO() public {
        uint256 reserveBefore = kiln.reserve();
        vm.prank(trader, trader); // 0 passes: cut = 1.30% of 1 ZTO = 0.013 ZTO
        BalanceDelta d = swapRouter.swap(
            key,
            IPoolManager.SwapParams(false, -1 ether, TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        assertEq(d.amount1(), -1 ether, "trader pays exactly 1 ZTO");
        assertGt(d.amount0(), 0, "trader receives ETH");
        assertEq(kiln.reserve(), reserveBefore + 0.013 ether, "cut credited to reserve");
        // After the trader has settled, the manager holds the trader's ZTO and the Kiln must be
        // able to realise its cut (directly or by burning claims) without exceeding backing.
        assertLe(kiln.reserve(), zto.balanceOf(address(kiln)) + manager.balanceOf(address(kiln), uint160(address(zto))));
    }

    receive() external payable {}
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {Kiln} from "src/Kiln.sol";
import {Launcher} from "src/Launcher.sol";

/// Minimal 18-decimal ERC-20 standing in for ZTO (WETH-like: reverts on insufficient balance).
contract ZTOToken {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "insufficient");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allowance");
        require(balanceOf[from] >= amount, "insufficient");
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

/// Minimal ERC-721 exposing only what the Kiln reads.
contract PepeoToken {
    mapping(address => uint256) public balanceOf;
    mapping(uint256 => address) public ownerOf;

    function mint(address to, uint256 id) external {
        require(ownerOf[id] == address(0), "minted");
        ownerOf[id] = to;
        balanceOf[to] += 1;
    }

    function transferFrom(address from, address to, uint256 id) external {
        require(ownerOf[id] == from && msg.sender == from, "auth");
        ownerOf[id] = to;
        balanceOf[from] -= 1;
        balanceOf[to] += 1;
    }
}

/// Kiln.afterSwap takes its ZTO cut out of the PoolManager as real tokens before the trader
/// settles the ZTO they are paying in. When the manager's real ZTO balance is below the cut,
/// every ZTO-in swap by a wallet with a nonzero cut reverts even though the pool holds the ETH
/// to pay the seller. A cut-free (21-pass) wallet trades the same route in the same state.
contract TakeBeforeSettleTest is Test {
    ZTOToken zto;
    PepeoToken pepeo;
    IPoolManager manager;
    Launcher launcher;
    Kiln kiln;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest liquidityRouter;
    PoolKey key;
    address seller = address(0xBEEF);
    address whale = address(0xCAFE);

    function setUp() public {
        zto = new ZTOToken();
        pepeo = new PepeoToken();
        manager = IPoolManager(address(new PoolManager(address(this))));
        swapRouter = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        uint256[] memory thresholds = new uint256[](4);
        thresholds[1] = 1;
        thresholds[2] = 4;
        thresholds[3] = 21;
        uint24[] memory cuts = new uint24[](4);
        cuts[0] = 13000;
        cuts[1] = 8000;
        cuts[2] = 3000;
        launcher = new Launcher(
            address(zto), address(pepeo), address(manager), 60, 2000, thresholds, cuts, 1500, 50
        );
        bytes32 hash = launcher.initCodeHash();
        bytes32 salt;
        while (true) {
            address predicted = address(
                uint160(uint256(keccak256(bytes.concat(hex"ff", bytes20(address(launcher)), salt, hash))))
            );
            if (uint160(predicted) & 0x3fff == 0x00cc) break;
            salt = bytes32(uint256(salt) + 1);
        }
        kiln = launcher.open(salt, 1 << 96);
        key = kiln.poolKey();

        // Deployer adds the ZTO-only range below the opening tick (v4 quotes ZTO per ETH).
        zto.mint(address(this), 1e24);
        zto.approve(address(liquidityRouter), 1e24);
        vm.deal(address(this), 1e24);
        liquidityRouter.modifyLiquidity(
            key, IPoolManager.ModifyLiquidityParams(-1200, -600, 1e22, bytes32(0)), ""
        );

        // Buyers sweep the whole ZTO inventory with ETH. The manager now holds ETH and ~no ZTO.
        vm.deal(whale, 1e24);
        vm.prank(whale, whale);
        swapRouter.swap{value: 1e24}(
            key,
            IPoolManager.SwapParams(true, -int256(1e24), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );

        zto.mint(seller, 100 ether);
        vm.prank(seller);
        zto.approve(address(swapRouter), 100 ether);
    }

    function _sellOneZTO() internal returns (bool ok) {
        vm.prank(seller, seller);
        (ok,) = address(swapRouter).call(
            abi.encodeCall(
                PoolSwapTest.swap,
                (
                    key,
                    IPoolManager.SwapParams(false, -int256(1 ether), TickMath.MAX_SQRT_PRICE - 1),
                    PoolSwapTest.TestSettings(false, false),
                    ""
                )
            )
        );
    }

    /// Fails on the current code: the 0-pass seller's 1 ZTO exact-input swap reverts inside
    /// afterSwap at poolManager.take(ZTO, kiln, 0.013e18) because the manager holds < 0.013 ZTO.
    function test_ztoInSwapWithCutRevertsWhenManagerHoldsLessZTOThanTheCut() public {
        uint256 cut = 1 ether * 13000 / 1_000_000;
        assertLt(zto.balanceOf(address(manager)), cut, "precondition: manager ZTO below the cut");
        assertGt(address(manager).balance, 1 ether, "precondition: pool has ETH to pay the seller");

        assertTrue(_sellOneZTO(), "ZTO-in swap by a 0-pass wallet must succeed when the pool has ETH");
    }

    /// Passes before and after the fix: a 21-pass wallet (cut 0) sells the same ZTO in the same state.
    function test_zeroCutWalletTradesTheSameRoute() public {
        for (uint256 i; i < 21; ++i) {
            pepeo.mint(seller, i);
        }
        assertTrue(_sellOneZTO(), "21-pass seller trades");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolSwapTest} from "@uniswap/v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "@uniswap/v4-core/src/test/PoolModifyLiquidityTest.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {Kiln} from "src/Kiln.sol";
import {Launcher} from "src/Launcher.sol";

/// Plain 18-decimal ERC-20 standing in for ZTO (WETH-like: reverts on insufficient balance).
contract ProofZTO {
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address to, uint256 amount) external returns (bool) {
        allowance[msg.sender][to] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "balance");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(allowance[from][msg.sender] >= amount, "allowance");
        allowance[from][msg.sender] -= amount;
        require(balanceOf[from] >= amount, "balance");
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ProofPEPEO is ERC721 {
    constructor() ERC721("P", "P") {}

    function mint(address to, uint256 id) external {
        _mint(to, id);
    }
}

/// Fails on the current Kiln: after the launch's ZTO-only range has been bought out, a wallet with
/// a nonzero kiln cut cannot sell ZTO into the pool at all, because afterSwap calls
/// poolManager.take(ZTO, kiln, cut) before the trader has settled any ZTO and the manager holds
/// none. Passes once the cut no longer requires the manager to already hold the ZTO.
contract TakeLivenessProofTest is Test {
    using PoolIdLibrary for PoolKey;
    using StateLibrary for IPoolManager;

    ProofZTO zto;
    ProofPEPEO pepeo;
    IPoolManager manager;
    Launcher launcher;
    Kiln kiln;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest liquidityRouter;
    PoolKey key;
    address trader = makeAddr("trader");
    address whale = makeAddr("whale");
    uint160 constant Q96 = 1 << 96;

    function setUp() public {
        zto = new ProofZTO();
        pepeo = new ProofPEPEO();
        manager = IPoolManager(address(new PoolManager(address(this))));
        swapRouter = new PoolSwapTest(manager);
        liquidityRouter = new PoolModifyLiquidityTest(manager);
        uint256[] memory thresholds = new uint256[](4);
        thresholds[1] = 1;
        thresholds[2] = 4;
        thresholds[3] = 21;
        uint24[] memory cuts = new uint24[](4);
        cuts[0] = 13000;
        cuts[1] = 8000;
        cuts[2] = 3000;
        launcher =
            new Launcher(address(zto), address(pepeo), address(manager), 60, 2000, thresholds, cuts, 1500, 50);
        bytes32 hash = launcher.initCodeHash();
        bytes32 salt;
        while (true) {
            address p = address(
                uint160(uint256(keccak256(bytes.concat(hex"ff", bytes20(address(launcher)), salt, hash))))
            );
            if (uint160(p) & 0x3fff == 0x00cc) break;
            salt = bytes32(uint256(salt) + 1);
        }
        kiln = launcher.open(salt, Q96);
        key = kiln.poolKey();
        vm.deal(address(this), 1e28);
        zto.mint(address(this), 1e28);
        zto.approve(address(liquidityRouter), 1e28);
        vm.deal(trader, 1e26);
        zto.mint(trader, 1e26);
        vm.prank(trader);
        zto.approve(address(swapRouter), 1e26);
        vm.deal(whale, 1e27);
        for (uint256 i; i < 21; ++i) {
            pepeo.mint(whale, 1000 + i);
        }
    }

    function test_tierZeroCanSellZtoAfterZtoRangeIsBoughtOut() public {
        // Launch flow from the brief: a ZTO-only range below the opening v4 tick.
        liquidityRouter.modifyLiquidity(
            key, IPoolManager.ModifyLiquidityParams(-1200, -600, 1e22, bytes32(0)), ""
        );
        // A 21-pass wallet (no cut, so nothing else interferes) buys the whole range out with ETH.
        vm.prank(whale, whale);
        swapRouter.swap{value: 2000 ether}(
            key,
            IPoolManager.SwapParams(true, -int256(1000 ether), TickMath.MIN_SQRT_PRICE + 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        (, int24 tick,,) = manager.getSlot0(key.toId());
        assertLt(tick, -1200, "price is below the range: the pool holds only ETH");
        assertLt(zto.balanceOf(address(manager)), 0.013 ether, "manager holds less ZTO than the cut");

        // Any wallet with a nonzero cut now sells 1 ZTO exact-in. Expected: swap succeeds, trader
        // receives ETH, the kiln takes 1.3% = 0.013 ZTO into reserve. Actual on current code: the
        // whole swap reverts inside afterSwap -> poolManager.take -> ZTO.transfer (insufficient balance).
        uint256 reserveBefore = kiln.reserve();
        uint256 ethBefore = trader.balance;
        vm.prank(trader, trader);
        BalanceDelta delta = swapRouter.swap(
            key,
            IPoolManager.SwapParams(false, -int256(1 ether), TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
        assertEq(int256(delta.amount1()), -1 ether, "trader paid exactly 1 ZTO");
        assertGt(trader.balance, ethBefore, "trader received ETH");
        assertEq(kiln.reserve(), reserveBefore + 0.013 ether, "cut landed in reserve");
        assertEq(zto.balanceOf(address(kiln)), kiln.reserve(), "reserve backed by real ZTO");
    }

    receive() external payable {}
}