Inference, liquid

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

/// @title HyperLiquidCU
/// @notice On-desk CLOB + CU ledger + ternary settlement. Sides are trits.
/// @dev Not mainnet. Address is a protocol hash of name, version, instrument.
contract HyperLiquidCU {
    int8 public constant PHI = 1;    // bid / keep
    int8 public constant SIGMA = 0;  // rest / skip
    int8 public constant OMEGA = -1; // ask / invert
    uint256 public constant PEG_USD = 1e18;
    uint16 public constant BASE_FEE_BPS = 200;
    uint16 public constant SIGMA_SKIM_BPS = 2000;
    uint16 public constant SLOT_BPS = 10000;
    uint16 public constant JAJJA_BPS = 10000;

    error NotTrit(int8 side);
    error ZeroAmount();
    error InsufficientCU(uint256 have, uint256 need);
    error BadTier(uint8 tier);

    struct Desk {
        uint64 nonce;
        uint256 balance;
        uint256 minted;
        uint256 burned;
        uint256 circulating;
        uint256 missionAccrued;
    }

    struct Level {
        uint256 price;
        uint256 size;
        int8 trit;
        uint32 orders;
    }

    struct Order {
        uint64 seq;
        int8 side;
        uint256 price;
        uint256 size;
        uint256 filled;
    }

    struct Settle {
        uint256 actualCu;
        uint256 surplus;
        uint256 distribution;
        uint16 energyBps;
    }

    bytes32 public immutable instrument;
    Desk public desk;
    Level[] public bids;
    Level[] public asks;
    mapping(uint64 => Order) public orders;

    modifier validTrit(int8 side) {
        if (side != PHI && side != SIGMA && side != OMEGA) revert NotTrit(side);
        _;
    }

    modifier positive(uint256 n) {
        if (n == 0) revert ZeroAmount();
        _;
    }

    modifier funded(uint256 n) {
        if (desk.balance < n) revert InsufficientCU(desk.balance, n);
        _;
    }

    constructor(bytes32 instrument_) {
        instrument = instrument_;
        desk.nonce = 0;
        emit Deployed(instrument_, "0.3.1-trit");
    }

    function mint(uint8 tier, uint256 amount)
        external
        positive(amount)
        returns (uint256 distribution)
    {
        if (tier > 2) revert BadTier(tier);
        uint256 gradeBps = tier == 0 ? 12500 : (tier == 1 ? 10000 : 9000);
        uint256 base = (amount * BASE_FEE_BPS) / 10_000;
        uint256 surplus = gradeBps > 10_000
            ? (amount * (gradeBps - 10_000)) / 10_000
            : 0;
        uint256 skim = (surplus * SIGMA_SKIM_BPS) / 10_000;
        distribution = base + skim;
        desk.balance += amount;
        desk.minted += amount;
        desk.circulating += amount;
        desk.missionAccrued += distribution;
        desk.nonce += 1;
        emit Minted(amount, tier, surplus);
    }

    function burn(uint256 amount)
        external
        positive(amount)
        funded(amount)
        returns (uint256 circulating)
    {
        desk.balance -= amount;
        desk.burned += amount;
        desk.circulating -= amount;
        desk.nonce += 1;
        circulating = desk.circulating;
        emit Burned(amount);
    }

    function placeLimit(int8 side, uint256 price, uint256 size)
        external
        validTrit(side)
        positive(size)
        positive(price)
        returns (uint64 seq)
    {
        seq = ++desk.nonce;
        orders[seq] = Order({seq: seq, side: side, price: price, size: size, filled: 0});
        if (side == SIGMA) {
            _rest(size);
            return seq;
        }
        _match(seq, side, price, size, false);
    }

    function placeMarket(int8 side, uint256 size)
        external
        validTrit(side)
        positive(size)
        returns (uint64 seq)
    {
        seq = ++desk.nonce;
        orders[seq] = Order({seq: seq, side: side, price: 0, size: size, filled: 0});
        _match(seq, side, 0, size, true);
    }

    function rest(uint256 size) external positive(size) returns (uint256 openInterest) {
        openInterest = _rest(size);
    }

    function settleTernary(uint256 fp16Cu, uint256 baselineCu, uint16 sparsityBps)
        external
        returns (uint256 actualCu, uint256 surplus, uint256 distribution)
    {
        uint256 mac = sparsityBps >= 10_000 ? 0 : 10_000 - sparsityBps;
        uint16 energyBps = uint16((1585 * (2200 + (7800 * mac) / 10_000)) / 16_000);
        if (energyBps < 400) energyBps = 400;
        actualCu = (fp16Cu * energyBps) / 10_000;
        if (desk.balance < actualCu) revert InsufficientCU(desk.balance, actualCu);
        surplus = baselineCu > actualCu ? baselineCu - actualCu : 0;
        uint256 base = (actualCu * BASE_FEE_BPS) / 10_000;
        uint256 skim = (surplus * SIGMA_SKIM_BPS) / 10_000;
        distribution = base + skim;
        desk.balance -= actualCu;
        desk.burned += actualCu;
        desk.circulating -= actualCu;
        desk.missionAccrued += distribution;
        desk.nonce += 1;
        emit TernarySettled(fp16Cu, actualCu, surplus);
    }

    /// I1 circulating == minted - burned == balance
    /// I2 every mint is tier-backed (enforced at mint)
    /// I3 burns are non-negative and balance-gated
    /// I4 share_bps locked (slots 10000, jajja 10000)
    function invariants() external view returns (bool[4] memory hold) {
        hold[0] = desk.circulating == desk.minted - desk.burned
            && desk.balance == desk.circulating;
        hold[1] = true;
        hold[2] = desk.burned <= desk.minted;
        hold[3] = SLOT_BPS == 10_000 && JAJJA_BPS == 10_000;
    }

    function _rest(uint256 size) internal returns (uint256 openInterest) {
        desk.nonce += 1;
        openInterest = size;
        emit Rest(size, openInterest);
    }

    function _match(uint64 seq, int8 side, uint256 price, uint256 size, bool market) internal {
        Level[] storage book = side == PHI ? asks : bids;
        uint256 remaining = size;
        uint256 filled;
        for (uint256 i = 0; i < book.length && remaining > 0; i++) {
            Level storage lvl = book[i];
            if (!market && side == PHI && price < lvl.price) break;
            if (!market && side == OMEGA && price > lvl.price) break;
            uint256 take = remaining < lvl.size ? remaining : lvl.size;
            remaining -= take;
            filled += take;
            int8 tritMac = int8(int256(int8(side)) * int256(lvl.trit));
            emit Fill(seq, lvl.price, take, tritMac);
        }
        orders[seq].filled = filled;
    }

    event Deployed(bytes32 instrument, string version);
    event Minted(uint256 amount, uint8 tier, uint256 surplus);
    event Burned(uint256 amount);
    event Fill(uint64 seq, uint256 price, uint256 size, int8 tritMac);
    event Rest(uint256 size, uint256 openInterest);
    event TernarySettled(uint256 fp16Cu, uint256 actualCu, uint256 surplus);
}