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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";

/// @notice Fails on the tree as it arrived: src/LaunchToken.sol does not exist, so the launch has no
/// token to deploy (SPEC.md section 3; the project floor's Token.protected.t.sol deploys it).
/// Passes once the fixed launch token exists: name "notSTOCK", symbol "NOTSTOCK", 18 decimals,
/// 1 000 000 000 tokens minted to msg.sender in the constructor, plain transfers, no constructor args.
contract LaunchTokenMissingTest is Test {
    uint256 internal constant SUPPLY = 1_000_000_000e18;

    function test_launchTokenIsTheSpecFixedToken() public {
        LaunchToken token = new LaunchToken();
        assertEq(token.name(), "notSTOCK", "name");
        assertEq(token.symbol(), "NOTSTOCK", "symbol");
        assertEq(uint256(token.decimals()), 18, "decimals");
        assertEq(token.totalSupply(), SUPPLY, "supply");
        assertEq(token.balanceOf(address(this)), SUPPLY, "whole supply minted to the deployer");

        address recipient = address(0xCAFE);
        assertTrue(token.transfer(recipient, 600_000_000e18), "transfer returned false");
        assertEq(token.balanceOf(recipient), 600_000_000e18, "recipient balance");
        assertEq(token.balanceOf(address(this)), 400_000_000e18, "sender balance");
        assertEq(token.totalSupply(), SUPPLY, "supply unchanged by a transfer");
    }

    function test_launchTokenHasNoMintOrOwnerPath() public {
        LaunchToken token = new LaunchToken();
        address attacker = address(0xBEEF);
        string[6] memory signatures = [
            "mint(address,uint256)",
            "mint(uint256)",
            "setOwner(address)",
            "transferOwnership(address)",
            "pause()",
            "upgradeTo(address)"
        ];
        for (uint256 i; i < signatures.length; ++i) {
            vm.prank(attacker);
            (bool ok,) = address(token).call(abi.encodeWithSignature(signatures[i], attacker, uint256(1)));
            ok;
            assertEq(token.totalSupply(), SUPPLY, signatures[i]);
            assertEq(token.balanceOf(attacker), 0, signatures[i]);
        }
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LpDesk} from "src/LpDesk.sol";

/// @dev A plain 18-decimal ERC-20 standing in for NOTSTOCK; nothing external is called at deploy.
contract MockNotStock {
    string public constant name = "notSTOCK";
    string public constant symbol = "NOTSTOCK";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {
        totalSupply = 1_000_000_000e18;
        balanceOf[msg.sender] = totalSupply;
    }

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

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

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

interface IBurner {
    function burn() external;
}

/// @notice Fails on the tree as it arrived: src/LpDesk.sol does not exist (SPEC.md section 2.1 and 2c).
/// Passes once LpDesk($token, operator, projectWallet) exists, creates Burner in its constructor,
/// exposes operator() and burner(), and burn(amount) moves free NOTSTOCK only to the dead address,
/// operator only, never above the free balance; Burner.burn() by anyone moves its whole balance to
/// the dead address and reverts on zero.
contract LpDeskMissingTest is Test {
    address internal constant DEV_WALLET = 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981;
    address internal constant PROJECT_WALLET = 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C;
    address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;

    MockNotStock internal token;
    LpDesk internal desk;

    function setUp() public {
        token = new MockNotStock();
        desk = new LpDesk(address(token), DEV_WALLET, PROJECT_WALLET);
    }

    function test_constructorFixesOperatorAndCreatesBurnerWithinSize() public view {
        assertEq(desk.operator(), DEV_WALLET, "operator is the dev wallet");
        address burner = desk.burner();
        assertGt(burner.code.length, 0, "Burner created by the constructor");
        assertLt(burner.code.length, 1_024, "Burner runtime under 1 024 bytes");
        assertLt(address(desk).code.length, 24_576, "LpDesk runtime under 24 576 bytes");
    }

    function test_burnerMovesItsWholeBalanceToDeadAndRevertsOnZero() public {
        IBurner burner = IBurner(desk.burner());
        vm.expectRevert();
        burner.burn();

        token.transfer(address(burner), 5e18);
        vm.prank(address(0xBEEF));
        burner.burn();
        assertEq(token.balanceOf(address(burner)), 0, "Burner emptied");
        assertEq(token.balanceOf(DEAD), 5e18, "dead received the whole balance");
    }

    function test_operatorBurnsFreeNotStockOnlyToDeadAndOnlyUpToFreeBalance() public {
        token.transfer(address(desk), 100e18);

        vm.prank(address(0xBEEF));
        vm.expectRevert();
        desk.burn(1);

        vm.prank(DEV_WALLET);
        vm.expectRevert();
        desk.burn(100e18 + 1);

        vm.prank(DEV_WALLET);
        desk.burn(40e18);
        assertEq(token.balanceOf(DEAD), 40e18, "exactly amount reached the dead address");
        assertEq(token.balanceOf(address(desk)), 60e18, "free balance reduced by exactly amount");
        assertEq(token.balanceOf(DEV_WALLET), 0, "operator received nothing");
        assertEq(token.balanceOf(PROJECT_WALLET), 0, "project wallet received nothing");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LpDesk} from "src/LpDesk.sol";
import {FirmVault} from "src/FirmVault.sol";

contract MockNotStock2 {
    string public constant name = "notSTOCK";
    string public constant symbol = "NOTSTOCK";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {
        totalSupply = 1_000_000_000e18;
        balanceOf[msg.sender] = totalSupply;
    }

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

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

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

/// @notice Fails on the tree as it arrived: src/FirmVault.sol does not exist (SPEC.md section 2.2 and 5).
/// Passes once FirmVault(projectWallet, lpDesk) exists with lpDesk() as a view, a runtime under
/// 10 240 bytes, distribute(token) that reverts until registerNotStock has succeeded, and
/// buyback(amount, minOut) that reverts for any caller but LpDesk's operator.
contract FirmVaultMissingTest is Test {
    address internal constant DEV_WALLET = 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981;
    address internal constant PROJECT_WALLET = 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C;
    address internal constant IMD = 0xFF0C532FDB8Cd566Ae169C1CB157ff2Bdc83E105;

    MockNotStock2 internal token;
    LpDesk internal desk;
    FirmVault internal vault;

    function setUp() public {
        token = new MockNotStock2();
        desk = new LpDesk(address(token), DEV_WALLET, PROJECT_WALLET);
        vault = new FirmVault(PROJECT_WALLET, address(desk));
    }

    function test_constructorFixesLpDeskAndStaysUnderSize() public view {
        assertEq(vault.lpDesk(), address(desk), "lpDesk() is the launch's LpDesk");
        assertLt(address(vault).code.length, 10_240, "FirmVault runtime under 10 240 bytes");
    }

    function test_distributeRevertsBeforeRegistration() public {
        token.transfer(address(vault), 1e18);
        vm.expectRevert();
        vault.distribute(address(token));
        vm.expectRevert();
        vault.distribute(IMD);
        assertEq(token.balanceOf(address(vault)), 1e18, "nothing moved before registration");
    }

    function test_buybackRevertsForAnyCallerButTheOperator() public {
        vm.prank(address(0xBEEF));
        vm.expectRevert();
        vault.buyback(1, 0);
        vm.prank(PROJECT_WALLET);
        vm.expectRevert();
        vault.buyback(1, 0);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LpDesk} from "src/LpDesk.sol";
import {GenesisSplitter} from "src/GenesisSplitter.sol";

contract MockNotStock3 {
    string public constant name = "notSTOCK";
    string public constant symbol = "NOTSTOCK";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() {
        totalSupply = 1_000_000_000e18;
        balanceOf[msg.sender] = totalSupply;
    }

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

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

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

/// @notice Fails on the tree as it arrived: src/GenesisSplitter.sol does not exist (SPEC.md section 2.3).
/// Passes once GenesisSplitter(lpDesk, devWallet) exists with a runtime under 2 048 bytes and a
/// split() that only ever moves 50/60 of its balance to LpDesk and 10/60 to the dev wallet, once:
/// before NOTSTOCK registration it either reverts or moves nothing; a second call moves nothing.
contract GenesisSplitterMissingTest is Test {
    address internal constant DEV_WALLET = 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981;
    address internal constant PROJECT_WALLET = 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C;

    MockNotStock3 internal token;
    LpDesk internal desk;
    GenesisSplitter internal splitter;

    function setUp() public {
        token = new MockNotStock3();
        desk = new LpDesk(address(token), DEV_WALLET, PROJECT_WALLET);
        splitter = new GenesisSplitter(address(desk), DEV_WALLET);
    }

    function test_runtimeUnderSize() public view {
        assertLt(address(splitter).code.length, 2_048, "GenesisSplitter runtime under 2 048 bytes");
    }

    function test_splitMovesOnlyTheFixedSharesAndOnlyOnce() public {
        token.transfer(address(splitter), 600_000_000e18);

        (bool ok,) = address(splitter).call(abi.encodeWithSignature("split()"));
        ok;
        uint256 kept = token.balanceOf(address(splitter));
        uint256 toDesk = token.balanceOf(address(desk));
        uint256 toDev = token.balanceOf(DEV_WALLET);
        bool untouched = kept == 600_000_000e18 && toDesk == 0 && toDev == 0;
        bool split = kept == 0 && toDesk == 500_000_000e18 && toDev == 100_000_000e18;
        assertTrue(untouched || split, "split() moved something other than 50/60 to LpDesk and 10/60 to the dev wallet");
        assertEq(token.balanceOf(PROJECT_WALLET), 0, "project wallet receives nothing from split()");

        if (split) {
            (ok,) = address(splitter).call(abi.encodeWithSignature("split()"));
            ok;
            assertEq(token.balanceOf(address(desk)), 500_000_000e18, "second split() moved nothing");
            assertEq(token.balanceOf(DEV_WALLET), 100_000_000e18, "second split() moved nothing");
        }
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {LpDesk} from "src/LpDesk.sol";
import {FirmVault} from "src/FirmVault.sol";
import {GenesisSplitter} from "src/GenesisSplitter.sol";
import {PriceGuard} from "src/PriceGuard.sol";
import {IERC20, IPoolManager, PoolKey, ILaunchRegistry} from "src/Interfaces.sol";

/// @dev Plain 18-decimal ERC-20 etched at the IMD address off the fork.
contract ProofERC20 {
    string public name = "Fren Pet";
    string public symbol = "IMD";
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

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

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

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

    function transferFrom(address f, address to, uint256 a) external returns (bool) {
        allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[to] += a;
        return true;
    }
}

/// @dev A pool manager whose exact-input swap is only partially filled: the pool runs out of
/// liquidity (or hits the price limit) after consuming 40% of the input, exactly as Uniswap v4's
/// Pool.swap ends its loop with amountSpecifiedRemaining != 0. It pays `OUT` of the other token.
contract PartialPoolManager {
    uint256 public constant FILL_BPS = 4000;
    uint256 public constant OUT = 1e18;
    address public lastSynced;

    function unlock(bytes calldata data) external returns (bytes memory) {
        (bool ok, bytes memory ret) = msg.sender.call(abi.encodeWithSignature("unlockCallback(bytes)", data));
        require(ok, "callback");
        return abi.decode(ret, (bytes));
    }

    function swap(PoolKey calldata, IPoolManager.SwapParams calldata p, bytes calldata) external pure returns (int256) {
        uint256 amountIn = uint256(-p.amountSpecified);
        uint256 paid = amountIn * FILL_BPS / 10_000;
        int128 a0;
        int128 a1;
        if (p.zeroForOne) {
            a0 = -int128(int256(paid));
            a1 = int128(int256(OUT));
        } else {
            a0 = int128(int256(OUT));
            a1 = -int128(int256(paid));
        }
        return int256((uint256(uint128(a0)) << 128) | uint256(uint128(a1)));
    }

    function sync(address c) external {
        lastSynced = c;
    }

    function settle() external payable returns (uint256) {
        return 0;
    }

    function take(address currency, address to, uint256 amount) external {
        require(IERC20(currency).transfer(to, amount), "take");
    }
}

/// @dev Stands in for the launch factory: deploys the launch so LpDesk's factory is this contract.
contract ProofFactory {
    address public poolHook = address(0xA00C);
    address public poolManager;
    PoolKey public key;
    address public requester;
    ILaunchRegistry.Artifact[] private _arts;

    LaunchToken public token;
    LpDesk public desk;
    FirmVault public vault;
    GenesisSplitter public splitter;

    constructor(address operator, address projectWallet, address devWallet, address imd, address pm) {
        poolManager = pm;
        token = new LaunchToken();
        desk = new LpDesk(address(token), operator, projectWallet);
        vault = new FirmVault(projectWallet, address(desk));
        splitter = new GenesisSplitter(address(desk), devWallet);
        (address c0, address c1) = address(token) < imd ? (address(token), imd) : (imd, address(token));
        key = PoolKey(c0, c1, 12500, 60, poolHook);
        requester = address(vault);
        _arts.push(ILaunchRegistry.Artifact("token", "LaunchToken", address(token)));
        _arts.push(ILaunchRegistry.Artifact("other", "LpDesk", address(desk)));
        _arts.push(ILaunchRegistry.Artifact("other", "FirmVault", address(vault)));
        _arts.push(ILaunchRegistry.Artifact("other", "GenesisSplitter", address(splitter)));
        token.transfer(projectWallet, token.totalSupply());
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, 0, 0, requester);
    }

    function registry() external view returns (address) {
        return address(this);
    }

    function artifactsOf(uint64) external view returns (ILaunchRegistry.Artifact[] memory) {
        return _arts;
    }
}

contract FirmVaultPartialFillTest is Test {
    address constant PROJECT = 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C;
    address constant DEV = 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981;
    address constant IMD = 0xFF0C532FDB8Cd566Ae169C1CB157ff2Bdc83E105;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;

    ProofFactory f;
    LaunchToken token;
    LpDesk desk;
    FirmVault vault;
    PriceGuard guard;
    PartialPoolManager pm;

    function setUp() public {
        ProofERC20 impl = new ProofERC20();
        vm.etch(IMD, address(impl).code);
        pm = new PartialPoolManager();
        f = new ProofFactory(DEV, PROJECT, DEV, IMD, address(pm));
        token = f.token();
        desk = f.desk();
        vault = f.vault();
        desk.deployModule(1, type(PriceGuard).creationCode);
        guard = PriceGuard(desk.priceGuard());
        vm.startPrank(PROJECT);
        token.transfer(address(f.splitter()), 600_000_000e18);
        token.transfer(address(pm), 10e18); // NOTSTOCK the pool pays out
        vm.stopPrank();
        guard.registerNotStock(1);
    }

    /// SPEC 5: the buyback bucket is "spent only on this buyback"; distribute() "never moves the
    /// buyback bucket". When the exact-input swap is only partially filled, buyback() still debits
    /// the bucket by the full `amount`, so the unswapped IMD silently becomes "undistributed" and
    /// the next distribute() pays 25% of it to the project wallet and 50% to LpDesk.
    function test_partialFillKeepsBucketImdInsideBucket() public {
        ProofERC20(IMD).mint(address(vault), 100e18);
        vm.prank(address(desk));
        vault.creditFromDesk(100e18); // 100% to the bucket (SPEC 2 / 5)
        assertEq(vault.buybackBucket(), 100e18);
        assertEq(vault.undistributed(), 0);
        uint256 projectBefore = IERC20(IMD).balanceOf(PROJECT);

        // Operator buys back with the whole bucket; the pool fills only 40% (40 IMD in, 1 NOTSTOCK out).
        vm.prank(DEV);
        try vault.buyback(100e18, 0) {} catch {}

        // Expected: bucket IMD never leaves the bucket except by being swapped. Actual: 60 IMD of
        // bucket money is now "undistributed" and distribute() hands 15 IMD of it to the project wallet.
        assertEq(IERC20(IMD).balanceOf(address(vault)), vault.buybackBucket(), "unswapped bucket IMD left the bucket");
        vault.distribute(IMD);
        assertEq(IERC20(IMD).balanceOf(PROJECT) - projectBefore, 0, "project wallet received bucket IMD");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {LpDesk} from "src/LpDesk.sol";
import {FirmVault} from "src/FirmVault.sol";
import {GenesisSplitter} from "src/GenesisSplitter.sol";
import {LpGovernor} from "src/LpGovernor.sol";
import {PriceGuard} from "src/PriceGuard.sol";
import {VenueV3} from "src/VenueV3.sol";
import {VenueV4} from "src/VenueV4.sol";
import {DeskSwap} from "src/DeskSwap.sol";
import {PoolKey, ILaunchRegistry, IERC20, IPoolManager} from "src/Interfaces.sol";

contract PlainERC20 {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(string memory n, string memory s, uint8 d) {
        name = n;
        symbol = s;
        decimals = d;
    }

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

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

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

    function transferFrom(address f, address to, uint256 a) external returns (bool) {
        allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[to] += a;
        return true;
    }
}

/// @dev Stands in for the launch factory: deploys the launch so LpDesk's factory is this contract.
contract Factory {
    address public poolHook = address(0xA00C);
    address public poolManager = address(0xBEEF);
    PoolKey public key;
    address public requester;
    ILaunchRegistry.Artifact[] private _arts;
    LaunchToken public token;
    LpDesk public desk;
    FirmVault public vault;
    GenesisSplitter public splitter;

    constructor(address operator, address projectWallet, address devWallet, address imd) {
        token = new LaunchToken();
        desk = new LpDesk(address(token), operator, projectWallet);
        vault = new FirmVault(projectWallet, address(desk));
        splitter = new GenesisSplitter(address(desk), devWallet);
        (address c0, address c1) = address(token) < imd ? (address(token), imd) : (imd, address(token));
        key = PoolKey(c0, c1, 12500, 60, poolHook);
        requester = address(vault);
        _arts.push(ILaunchRegistry.Artifact("token", "LaunchToken", address(token)));
        _arts.push(ILaunchRegistry.Artifact("other", "LpDesk", address(desk)));
        _arts.push(ILaunchRegistry.Artifact("other", "FirmVault", address(vault)));
        _arts.push(ILaunchRegistry.Artifact("other", "GenesisSplitter", address(splitter)));
        token.transfer(projectWallet, token.totalSupply());
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, 0, 0, requester);
    }

    function registry() external view returns (address) {
        return address(this);
    }

    function artifactsOf(uint64) external view returns (ILaunchRegistry.Artifact[] memory) {
        return _arts;
    }
}

interface IUnlockCallback {
    function unlockCallback(bytes calldata) external returns (bytes memory);
}

/// @dev A pool manager whose pool runs out of liquidity half way: an exact-input swap of X
/// consumes only X/2 (the price limit is reached), paying out 1:1 on what it consumed.
contract HalfDepthPoolManager {
    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function swap(PoolKey memory, IPoolManager.SwapParams memory p, bytes calldata) external pure returns (int256 d) {
        uint256 consumed = uint256(-p.amountSpecified) / 2;
        int128 inDelta = -int128(int256(consumed));
        int128 outDelta = int128(int256(consumed));
        (int128 a0, int128 a1) = p.zeroForOne ? (inDelta, outDelta) : (outDelta, inDelta);
        assembly {
            d := or(shl(128, a0), and(sub(shl(128, 1), 1), a1))
        }
    }

    function sync(address) external {}

    function settle() external payable returns (uint256) {
        return 0;
    }

    function take(address currency, address to, uint256 amount) external {
        IERC20(currency).transfer(to, amount);
    }
}

contract BuybackPartialFillTest is Test {
    address constant PROJECT = 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C;
    address constant DEV = 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981;
    address constant IMD = 0xFF0C532FDB8Cd566Ae169C1CB157ff2Bdc83E105;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;

    Factory f;
    LaunchToken token;
    LpDesk desk;
    FirmVault vault;
    PlainERC20 imd;

    function setUp() public {
        vm.etch(IMD, address(new PlainERC20("Fren Pet", "IMD", 18)).code);
        imd = PlainERC20(IMD);
        f = new Factory(DEV, PROJECT, DEV, IMD);
        token = f.token();
        desk = f.desk();
        vault = f.vault();
        desk.deployModule(0, type(LpGovernor).creationCode);
        desk.deployModule(1, type(PriceGuard).creationCode);
        desk.deployModule(2, type(VenueV3).creationCode);
        desk.deployModule(3, type(VenueV4).creationCode);
        desk.deployModule(4, type(DeskSwap).creationCode);
        GenesisSplitter splitter = f.splitter();
        address pm = f.poolManager();
        vm.prank(PROJECT);
        token.transfer(address(splitter), 600_000_000e18);
        PriceGuard(desk.priceGuard()).registerNotStock(1);
        splitter.split();
        // The launch pool's manager, holding NOTSTOCK to pay the buyback out.
        vm.etch(pm, address(new HalfDepthPoolManager()).code);
        vm.prank(PROJECT);
        token.transfer(pm, 1_000_000e18);
    }

    /// Bucket 100 IMD. The operator buys back 100 IMD but the pool absorbs only 50. The unspent
    /// 50 IMD must stay reserved for buybacks (or the call must revert); instead the bucket drops
    /// by the full 100 and the 50 IMD becomes "undistributed", which the next distribute() hands
    /// 25% to the project wallet and 50% to LpDesk.
    function test_partialFillKeepsUnspentImdInTheBucket() public {
        imd.mint(address(vault), 400e18);
        vault.distribute(IMD);
        assertEq(vault.buybackBucket(), 100e18);
        assertEq(vault.undistributed(), 0);
        uint256 deadBefore = token.balanceOf(DEAD);

        vm.prank(DEV);
        try vault.buyback(100e18, 0) {} catch {}

        uint256 spent = 100e18 - imd.balanceOf(address(vault));
        // Whatever was actually swapped, no bucket IMD may fall outside the bucket.
        assertEq(vault.undistributed(), 0, "unspent buyback IMD left the bucket");
        assertEq(vault.buybackBucket(), 100e18 - spent, "bucket must drop only by what was swapped");
        assertEq(token.balanceOf(DEAD) - deadBefore, spent, "dead receives the swap output");
    }

    /// The same state one call later: distribute() pays the project wallet out of bucket money.
    function test_partialFillLeaksBucketImdToProjectWallet() public {
        imd.mint(address(vault), 400e18);
        vault.distribute(IMD);
        uint256 projectBefore = imd.balanceOf(PROJECT);
        vm.prank(DEV);
        try vault.buyback(100e18, 0) {} catch {}
        vault.distribute(IMD);
        assertEq(imd.balanceOf(PROJECT), projectBefore, "project wallet received buyback-bucket IMD");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {LaunchToken} from "src/LaunchToken.sol";
import {LpDesk} from "src/LpDesk.sol";
import {FirmVault} from "src/FirmVault.sol";
import {GenesisSplitter} from "src/GenesisSplitter.sol";
import {LpGovernor} from "src/LpGovernor.sol";
import {PriceGuard} from "src/PriceGuard.sol";
import {VenueV3} from "src/VenueV3.sol";
import {VenueV4} from "src/VenueV4.sol";
import {DeskSwap} from "src/DeskSwap.sol";
import {PoolKey, ILaunchRegistry, IERC20, IPoolManager} from "src/Interfaces.sol";

contract PlainERC20 {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor(string memory n, string memory s, uint8 d) {
        name = n;
        symbol = s;
        decimals = d;
    }

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

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

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

    function transferFrom(address f, address to, uint256 a) external returns (bool) {
        allowance[f][msg.sender] -= a;
        balanceOf[f] -= a;
        balanceOf[to] += a;
        return true;
    }
}

/// @dev Stands in for the launch factory: deploys the launch so LpDesk's factory is this contract.
contract Factory {
    address public poolHook = address(0xA00C);
    address public poolManager = address(0xBEEF);
    PoolKey public key;
    address public requester;
    ILaunchRegistry.Artifact[] private _arts;
    LaunchToken public token;
    LpDesk public desk;
    FirmVault public vault;
    GenesisSplitter public splitter;

    constructor(address operator, address projectWallet, address devWallet, address imd) {
        token = new LaunchToken();
        desk = new LpDesk(address(token), operator, projectWallet);
        vault = new FirmVault(projectWallet, address(desk));
        splitter = new GenesisSplitter(address(desk), devWallet);
        (address c0, address c1) = address(token) < imd ? (address(token), imd) : (imd, address(token));
        key = PoolKey(c0, c1, 12500, 60, poolHook);
        requester = address(vault);
        _arts.push(ILaunchRegistry.Artifact("token", "LaunchToken", address(token)));
        _arts.push(ILaunchRegistry.Artifact("other", "LpDesk", address(desk)));
        _arts.push(ILaunchRegistry.Artifact("other", "FirmVault", address(vault)));
        _arts.push(ILaunchRegistry.Artifact("other", "GenesisSplitter", address(splitter)));
        token.transfer(projectWallet, token.totalSupply());
    }

    function positionOf(uint64) external view returns (PoolKey memory, int24, int24, address) {
        return (key, 0, 0, requester);
    }

    function registry() external view returns (address) {
        return address(this);
    }

    function artifactsOf(uint64) external view returns (ILaunchRegistry.Artifact[] memory) {
        return _arts;
    }
}

interface IUnlockCallback {
    function unlockCallback(bytes calldata) external returns (bytes memory);
}

/// @dev A pool manager whose pool runs out of liquidity half way: an exact-input swap of X
/// consumes only X/2 (the price limit is reached), paying out 1:1 on what it consumed.
contract HalfDepthPoolManager {
    function unlock(bytes calldata data) external returns (bytes memory) {
        return IUnlockCallback(msg.sender).unlockCallback(data);
    }

    function swap(PoolKey memory, IPoolManager.SwapParams memory p, bytes calldata) external pure returns (int256 d) {
        uint256 consumed = uint256(-p.amountSpecified) / 2;
        int128 inDelta = -int128(int256(consumed));
        int128 outDelta = int128(int256(consumed));
        (int128 a0, int128 a1) = p.zeroForOne ? (inDelta, outDelta) : (outDelta, inDelta);
        assembly {
            d := or(shl(128, a0), and(sub(shl(128, 1), 1), a1))
        }
    }

    function sync(address) external {}

    function settle() external payable returns (uint256) {
        return 0;
    }

    function take(address currency, address to, uint256 amount) external {
        IERC20(currency).transfer(to, amount);
    }
}

contract BuybackPartialFillTest is Test {
    address constant PROJECT = 0x3c587Eff6c96eAcF7E3dcC2CFf6416161386E48C;
    address constant DEV = 0x8Ad18E99F4C8d8406f9Ba8899CF308000518A981;
    address constant IMD = 0xFF0C532FDB8Cd566Ae169C1CB157ff2Bdc83E105;
    address constant DEAD = 0x000000000000000000000000000000000000dEaD;

    Factory f;
    LaunchToken token;
    LpDesk desk;
    FirmVault vault;
    PlainERC20 imd;

    function setUp() public {
        vm.etch(IMD, address(new PlainERC20("Fren Pet", "IMD", 18)).code);
        imd = PlainERC20(IMD);
        f = new Factory(DEV, PROJECT, DEV, IMD);
        token = f.token();
        desk = f.desk();
        vault = f.vault();
        desk.deployModule(0, type(LpGovernor).creationCode);
        desk.deployModule(1, type(PriceGuard).creationCode);
        desk.deployModule(2, type(VenueV3).creationCode);
        desk.deployModule(3, type(VenueV4).creationCode);
        desk.deployModule(4, type(DeskSwap).creationCode);
        GenesisSplitter splitter = f.splitter();
        address pm = f.poolManager();
        vm.prank(PROJECT);
        token.transfer(address(splitter), 600_000_000e18);
        PriceGuard(desk.priceGuard()).registerNotStock(1);
        splitter.split();
        // The launch pool's manager, holding NOTSTOCK to pay the buyback out.
        vm.etch(pm, address(new HalfDepthPoolManager()).code);
        vm.prank(PROJECT);
        token.transfer(pm, 1_000_000e18);
    }

    /// Bucket 100 IMD. The operator buys back 100 IMD but the pool absorbs only 50. The unspent
    /// 50 IMD must stay reserved for buybacks (or the call must revert); instead the bucket drops
    /// by the full 100 and the 50 IMD becomes "undistributed", which the next distribute() hands
    /// 25% to the project wallet and 50% to LpDesk.
    function test_partialFillKeepsUnspentImdInTheBucket() public {
        imd.mint(address(vault), 400e18);
        vault.distribute(IMD);
        assertEq(vault.buybackBucket(), 100e18);
        assertEq(vault.undistributed(), 0);
        uint256 deadBefore = token.balanceOf(DEAD);

        vm.prank(DEV);
        try vault.buyback(100e18, 0) {} catch {}

        uint256 spent = 100e18 - imd.balanceOf(address(vault));
        // Whatever was actually swapped, no bucket IMD may fall outside the bucket.
        assertEq(vault.undistributed(), 0, "unspent buyback IMD left the bucket");
        assertEq(vault.buybackBucket(), 100e18 - spent, "bucket must drop only by what was swapped");
        assertEq(token.balanceOf(DEAD) - deadBefore, spent, "dead receives the swap output");
    }

    /// The same state one call later: distribute() pays the project wallet out of bucket money.
    function test_partialFillLeaksBucketImdToProjectWallet() public {
        imd.mint(address(vault), 400e18);
        vault.distribute(IMD);
        uint256 projectBefore = imd.balanceOf(PROJECT);
        vm.prank(DEV);
        try vault.buyback(100e18, 0) {} catch {}
        vault.distribute(IMD);
        assertEq(imd.balanceOf(PROJECT), projectBefore, "project wallet received buyback-bucket IMD");
    }
}