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

import {Test} from "forge-std/Test.sol";
import {IMD6900PonsLaunch} from "src/IMD6900PonsLaunch.sol";
import {PonsTokenParams} from "src/IPons.sol";

/// @dev Minimal stand-ins for Pons: a coin, a curve that keeps no fees, an escrow with nothing to claim.
contract Coin {
    mapping(address => uint256) public balanceOf;
    function mint(address to, uint256 a) external { balanceOf[to] += a; }
    function transfer(address to, uint256 a) external returns (bool) { balanceOf[msg.sender] -= a; balanceOf[to] += a; return true; }
}

contract Escrow {
    function balanceOf(address) external pure returns (uint256) { return 0; }
    function claim() external pure returns (uint256) { return 0; }
}

contract Curve {
    Coin public immutable coin;
    constructor(Coin c) { coin = c; }
    function graduated() external pure returns (bool) { return false; }
    function sweepFees(uint256) external {}
    function buy(uint256 quoteIn, uint256, address to) external payable returns (uint256 out) {
        require(msg.value == quoteIn, "value");
        out = quoteIn * 250_000_000;
        coin.mint(to, out);
    }
}

contract Factory {
    uint256 public constant launchFee = 0.0005 ether;
    address public immutable feeEscrow = address(new Escrow());
    address public constant memeHook = address(0xbeef);
    function previewLaunchEconomics(uint256, address) external pure returns (bytes32) { return bytes32(uint256(1)); }
    function launchToken(PonsTokenParams calldata, uint256, address) external payable returns (address token, address curve) {
        require(msg.value == launchFee, "fee");
        Coin c = new Coin();
        return (address(c), address(new Curve(c)));
    }
}

/// @notice The default payees are read live: 30% to owner(). Solady's Ownable exposes renounceOwnership(), after
///         which owner() is address(0) and every split() sends 30% of the fees to address(0), where nothing can
///         recover it. The pot bridge still gets its 70%, so nothing reverts and nothing warns.
contract DefaultPayeeRenounceTest is Test {
    address constant OWNER = address(0xA11CE);

    function test_SplitNeverPaysAddressZero() public {
        Factory factory = new Factory();
        IMD6900PonsLaunch l = new IMD6900PonsLaunch(OWNER, address(factory), address(new Coin()), address(0x7133));
        vm.deal(OWNER, 1 ether);
        vm.prank(OWNER);
        l.launch{value: 1 ether}(bytes32(0), address(0), 0, 0);

        vm.prank(OWNER);
        l.renounceOwnership();
        (address[] memory to,) = l.payees();
        assertEq(to[1], address(0), "the default ops payee is now address(0)");

        vm.deal(address(this), 1 ether);
        l.addFees{value: 1 ether}();
        uint256 burnedBefore = address(0).balance;
        l.split();
        assertEq(address(0).balance - burnedBefore, 0, "fees must never be sent to address(0)");
        assertEq(l.POT_BRIDGE().balance, 0.7 ether);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMD6900PonsLaunch} from "src/IMD6900PonsLaunch.sol";
import {PonsTokenParams} from "src/IPons.sol";

/// @dev Minimal coin: whole supply minted to the curve, plain transfers.
contract Coin {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    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;
    }
}

contract Escrow {
    mapping(address => uint256) public balanceOf;

    function claim() external returns (uint256) {
        return 0;
    }
}

/// @dev A Pons-like curve: a buy larger than the sellable allocation is filled up to it, charged only for what it
///      took, and the remainder is refunded to msg.sender (PonsV2BondingCurve.buy, "CurveBuyRefunded").
contract ClampingCurve {
    Coin public immutable token;
    uint256 public constant SELLABLE = 100e18; // 1 ETH buys it all at 100 coin / ETH
    bool public graduated;

    constructor(Coin t) {
        token = t;
    }

    function buy(uint256 quoteIn, uint256, address to) external payable returns (uint256 out) {
        require(msg.value == quoteIn, "value");
        uint256 spent = quoteIn;
        out = spent * 100;
        if (out > SELLABLE) {
            out = SELLABLE;
            spent = 1 ether;
        }
        token.transfer(to, out);
        uint256 refund = quoteIn - spent;
        if (refund != 0) {
            (bool ok,) = msg.sender.call{value: refund}("");
            require(ok, "refund");
        }
        graduated = true;
    }
}

contract Factory {
    uint256 public constant launchFee = 0.0005 ether;
    address public immutable feeEscrow = address(new Escrow());
    address public constant memeHook = address(0xbeef);
    bytes32 public constant economics = keccak256("economics");

    function previewLaunchEconomics(uint256, address) external pure returns (bytes32) {
        return economics;
    }

    function launchToken(PonsTokenParams calldata p, uint256, address)
        external
        payable
        returns (address token, address curve)
    {
        require(msg.value == launchFee, "fee");
        Coin t = new Coin{salt: p.salt}();
        ClampingCurve c = new ClampingCurve(t);
        t.mint(address(c), 100e18);
        return (address(t), address(c));
    }

    function predict(bytes32 salt) external view returns (address) {
        return address(
            uint160(
                uint256(
                    keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(type(Coin).creationCode)))
                )
            )
        );
    }
}

contract PartialFillTest is Test {
    address constant OWNER = 0x35dA9C0303507ddf708E87F2568EdDf12c47a059;

    function test_launchEthOverstatesTheOpeningBuyOnAPartialFill() public {
        Factory f = new Factory();
        IMD6900PonsLaunch l = new IMD6900PonsLaunch(OWNER, address(f), address(0xdead), address(0xbeef));
        PonsTokenParams memory m = l.meta();
        m.expectedEconomics = f.economics();
        vm.prank(OWNER);
        l.setMeta(m);
        vm.deal(address(l), 3 ether + 0.0005 ether); // the team's ETH, more than the curve can sell
        bytes32 salt = keccak256("s");
        address expected = f.predict(salt);
        uint256 ownerBefore = OWNER.balance;
        vm.prank(OWNER);
        (, uint256 bought) = l.launch(salt, expected, 0, 0);
        assertEq(bought, 100e18, "filled only up to the sellable allocation");
        assertEq(OWNER.balance - ownerBefore, 2 ether, "the refunded 2 ETH went to the owner");
        // The record says 3 ETH were spent on the opening buy; only 1 ETH was (the curve refunded 2 ETH).
        assertEq(l.launchEth(), 1 ether, "launchEth should equal what the curve actually took");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMD6900PonsLaunch} from "src/IMD6900PonsLaunch.sol";
import {PonsTokenParams} from "src/IPons.sol";

contract SCToken {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    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;
    }
}

contract SCEscrow {
    function balanceOf(address) external pure returns (uint256) {
        return 0;
    }

    function claim() external pure returns (uint256) {
        return 0;
    }
}

contract SCCurve {
    SCToken immutable token;

    constructor(SCToken t) {
        token = t;
    }

    function graduated() external pure returns (bool) {
        return false;
    }

    function sweepFees(uint256) external {}

    function buy(uint256 quoteIn, uint256, address to) external payable returns (uint256 out) {
        out = quoteIn * 250_000_000;
        token.mint(to, out);
    }
}

contract SCFactory {
    uint256 public constant launchFee = 0.0005 ether;
    SCEscrow public immutable feeEscrow = new SCEscrow();
    address public constant memeHook = address(0xbeef);

    function launchToken(PonsTokenParams calldata p, uint256, address) external payable returns (address, address) {
        require(msg.value == launchFee);
        SCToken t = new SCToken{salt: p.salt}();
        return (address(t), address(new SCCurve(t)));
    }

    function predict(bytes32 salt) external view returns (address) {
        return address(
            uint160(
                uint256(
                    keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(type(SCToken).creationCode)))
                )
            )
        );
    }
}

contract Refuser {
    receive() external payable {
        revert("refused");
    }
}

/// @notice After the Robinhood timelock recovers the ETH behind a refused share and the owner removes that payee,
///         the next fees are not split among the current payees: the removed payee's stale credit absorbs them first.
contract StaleCreditTest is Test {
    address constant OWNER = 0x35dA9C0303507ddf708E87F2568EdDf12c47a059;
    address constant TIMELOCK = 0x16D3f65B708883DF042d98E1C7a49B32A33E2A14;
    IMD6900PonsLaunch l;

    function setUp() public {
        SCFactory factory = new SCFactory();
        SCToken imdstr = new SCToken();
        l = new IMD6900PonsLaunch(OWNER, address(factory), address(imdstr), TIMELOCK);
        PonsTokenParams memory m = l.meta();
        m.expectedEconomics = keccak256("pinned");
        vm.prank(OWNER);
        l.setMeta(m);
        vm.deal(address(l), 1 ether);
        bytes32 salt = keccak256("s");
        address predicted = factory.predict(salt);
        vm.prank(OWNER);
        l.launch(salt, predicted, 0, 0);
        vm.deal(address(this), 10 ether);
    }

    function _payees(address a, address b, uint16 share) internal {
        address[] memory to = new address[](2);
        uint16[] memory bps = new uint16[](2);
        (to[0], to[1], bps[0], bps[1]) = (a, b, share, 10_000 - share);
        vm.prank(OWNER);
        l.setPayees(to, bps);
    }

    function test_RecoveredCreditOfARemovedPayeeStillTakesTheNextFeesFirst() public {
        address refuser = address(new Refuser());
        address ops = makeAddr("ops");
        _payees(refuser, ops, 5_000);
        l.addFees{value: 1 ether}();
        l.split(); // ops 0.5 ETH; the refuser's 0.5 ETH stays here as its credit
        assertEq(address(l).balance, 0.5 ether);

        vm.prank(TIMELOCK);
        l.recoverEth(makeAddr("rescued"), 0); // the timelock takes the refused 0.5 ETH out
        assertEq(address(l).balance, 0);
        _payees(l.POT_BRIDGE(), ops, 7_000); // the owner drops the refuser from the split

        l.addFees{value: 1 ether}(); // the next fees
        uint256 potBefore = l.POT_BRIDGE().balance;
        uint256 opsBefore = ops.balance;
        uint256 allocated = l.split();

        // Expected: the 1 ETH of new fees is split 70/30 between the current payees.
        // Actual: only 0.5 ETH is allocated (0.35 / 0.15); 0.5 ETH is held again for the removed refuser,
        // whose backing the timelock already recovered. Every later recovery recreates the same hole.
        assertEq(allocated, 1 ether, "new fees allocated to the current payees");
        assertEq(l.POT_BRIDGE().balance - potBefore, 0.7 ether, "pot share");
        assertEq(ops.balance - opsBefore, 0.3 ether, "ops share");
        assertEq(address(l).balance, 0, "nothing re-reserved for the removed payee");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMD6900PonsLaunch} from "src/IMD6900PonsLaunch.sol";
import {PonsTokenParams} from "src/IPons.sol";

/// @dev Minimal coin: whole supply minted to the curve, plain transfers.
contract Coin {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    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;
    }
}

contract Escrow {
    mapping(address => uint256) public balanceOf;

    function claim() external returns (uint256) {
        return 0;
    }
}

/// @dev A Pons-like curve: a buy larger than the sellable allocation is filled up to it, charged only for what it
///      took, and the remainder is refunded to msg.sender (PonsV2BondingCurve.buy, "CurveBuyRefunded").
contract ClampingCurve {
    Coin public immutable token;
    uint256 public constant SELLABLE = 100e18; // 1 ETH buys it all at 100 coin / ETH
    bool public graduated;

    constructor(Coin t) {
        token = t;
    }

    function buy(uint256 quoteIn, uint256, address to) external payable returns (uint256 out) {
        require(msg.value == quoteIn, "value");
        uint256 spent = quoteIn;
        out = spent * 100;
        if (out > SELLABLE) {
            out = SELLABLE;
            spent = 1 ether;
        }
        token.transfer(to, out);
        uint256 refund = quoteIn - spent;
        if (refund != 0) {
            (bool ok,) = msg.sender.call{value: refund}("");
            require(ok, "refund");
        }
        graduated = true;
    }
}

contract Factory {
    uint256 public constant launchFee = 0.0005 ether;
    address public immutable feeEscrow = address(new Escrow());
    address public constant memeHook = address(0xbeef);
    bytes32 public constant economics = keccak256("economics");

    function previewLaunchEconomics(uint256, address) external pure returns (bytes32) {
        return economics;
    }

    function launchToken(PonsTokenParams calldata p, uint256, address)
        external
        payable
        returns (address token, address curve)
    {
        require(msg.value == launchFee, "fee");
        Coin t = new Coin{salt: p.salt}();
        ClampingCurve c = new ClampingCurve(t);
        t.mint(address(c), 100e18);
        return (address(t), address(c));
    }

    function predict(bytes32 salt) external view returns (address) {
        return address(
            uint160(
                uint256(
                    keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(type(Coin).creationCode)))
                )
            )
        );
    }
}

contract PartialFillTest is Test {
    address constant OWNER = 0x35dA9C0303507ddf708E87F2568EdDf12c47a059;

    function test_launchEthOverstatesTheOpeningBuyOnAPartialFill() public {
        Factory f = new Factory();
        IMD6900PonsLaunch l = new IMD6900PonsLaunch(OWNER, address(f), address(0xdead), address(0xbeef));
        PonsTokenParams memory m = l.meta();
        m.expectedEconomics = f.economics();
        vm.prank(OWNER);
        l.setMeta(m);
        vm.deal(address(l), 3 ether + 0.0005 ether); // the team's ETH, more than the curve can sell
        bytes32 salt = keccak256("s");
        address expected = f.predict(salt);
        uint256 ownerBefore = OWNER.balance;
        vm.prank(OWNER);
        (, uint256 bought) = l.launch(salt, expected, 0, 0);
        assertEq(bought, 100e18, "filled only up to the sellable allocation");
        assertEq(OWNER.balance - ownerBefore, 2 ether, "the refunded 2 ETH went to the owner");
        // The record says 3 ETH were spent on the opening buy; only 1 ETH was (the curve refunded 2 ETH).
        assertEq(l.launchEth(), 1 ether, "launchEth should equal what the curve actually took");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IMD6900PonsLaunch} from "src/IMD6900PonsLaunch.sol";
import {PonsTokenParams} from "src/IPons.sol";

contract SCToken {
    mapping(address => uint256) public balanceOf;
    uint256 public totalSupply;

    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;
    }
}

contract SCEscrow {
    function balanceOf(address) external pure returns (uint256) {
        return 0;
    }

    function claim() external pure returns (uint256) {
        return 0;
    }
}

contract SCCurve {
    SCToken immutable token;

    constructor(SCToken t) {
        token = t;
    }

    function graduated() external pure returns (bool) {
        return false;
    }

    function sweepFees(uint256) external {}

    function buy(uint256 quoteIn, uint256, address to) external payable returns (uint256 out) {
        out = quoteIn * 250_000_000;
        token.mint(to, out);
    }
}

contract SCFactory {
    uint256 public constant launchFee = 0.0005 ether;
    SCEscrow public immutable feeEscrow = new SCEscrow();
    address public constant memeHook = address(0xbeef);

    function launchToken(PonsTokenParams calldata p, uint256, address) external payable returns (address, address) {
        require(msg.value == launchFee);
        SCToken t = new SCToken{salt: p.salt}();
        return (address(t), address(new SCCurve(t)));
    }

    function predict(bytes32 salt) external view returns (address) {
        return address(
            uint160(
                uint256(
                    keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(type(SCToken).creationCode)))
                )
            )
        );
    }
}

contract Refuser {
    receive() external payable {
        revert("refused");
    }
}

/// @notice After the Robinhood timelock recovers the ETH behind a refused share and the owner removes that payee,
///         the next fees are not split among the current payees: the removed payee's stale credit absorbs them first.
contract StaleCreditTest is Test {
    address constant OWNER = 0x35dA9C0303507ddf708E87F2568EdDf12c47a059;
    address constant TIMELOCK = 0x16D3f65B708883DF042d98E1C7a49B32A33E2A14;
    IMD6900PonsLaunch l;

    function setUp() public {
        SCFactory factory = new SCFactory();
        SCToken imdstr = new SCToken();
        l = new IMD6900PonsLaunch(OWNER, address(factory), address(imdstr), TIMELOCK);
        PonsTokenParams memory m = l.meta();
        m.expectedEconomics = keccak256("pinned");
        vm.prank(OWNER);
        l.setMeta(m);
        vm.deal(address(l), 1 ether);
        bytes32 salt = keccak256("s");
        address predicted = factory.predict(salt);
        vm.prank(OWNER);
        l.launch(salt, predicted, 0, 0);
        vm.deal(address(this), 10 ether);
    }

    function _payees(address a, address b, uint16 share) internal {
        address[] memory to = new address[](2);
        uint16[] memory bps = new uint16[](2);
        (to[0], to[1], bps[0], bps[1]) = (a, b, share, 10_000 - share);
        vm.prank(OWNER);
        l.setPayees(to, bps);
    }

    function test_RecoveredCreditOfARemovedPayeeStillTakesTheNextFeesFirst() public {
        address refuser = address(new Refuser());
        address ops = makeAddr("ops");
        _payees(refuser, ops, 5_000);
        l.addFees{value: 1 ether}();
        l.split(); // ops 0.5 ETH; the refuser's 0.5 ETH stays here as its credit
        assertEq(address(l).balance, 0.5 ether);

        vm.prank(TIMELOCK);
        l.recoverEth(makeAddr("rescued"), 0); // the timelock takes the refused 0.5 ETH out
        assertEq(address(l).balance, 0);
        _payees(l.POT_BRIDGE(), ops, 7_000); // the owner drops the refuser from the split

        l.addFees{value: 1 ether}(); // the next fees
        uint256 potBefore = l.POT_BRIDGE().balance;
        uint256 opsBefore = ops.balance;
        uint256 allocated = l.split();

        // Expected: the 1 ETH of new fees is split 70/30 between the current payees.
        // Actual: only 0.5 ETH is allocated (0.35 / 0.15); 0.5 ETH is held again for the removed refuser,
        // whose backing the timelock already recovered. Every later recovery recreates the same hole.
        assertEq(allocated, 1 ether, "new fees allocated to the current payees");
        assertEq(l.POT_BRIDGE().balance - potBefore, 0.7 ether, "pot share");
        assertEq(ops.balance - opsBefore, 0.3 ether, "ops share");
        assertEq(address(l).balance, 0, "nothing re-reserved for the removed payee");
    }
}