T23 · Perp DEX

証拠金を超える損失の条件：

    清算発動から決済完了までのマーク価格の変動幅
                >
    維持証拠金率 + 清算用に確保した部分

内訳：
  左辺 = 相場の速度 × 清算遅延     ← 自分では制御できない部分
  右辺 = 設定したパラメータ       ← 設計できる部分

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

uint256 constant BPS = 10_000;

/// マーク価格：外部指数を基準に、小さな偏差だけを許す
function markPrice() public view returns (uint256) {
    uint256 index = priceGuard.readPrice();   // T21の四つの検査はこの関数内にある
    uint256 last = lastTradePrice;

    uint256 upper = index * (BPS + markBandBps) / BPS;   // markBandBpsは設定可能。典型的には数十から数百
    uint256 lower = index * (BPS - markBandBps) / BPS;

    if (last > upper) return upper;
    if (last < lower) return lower;
    return last;
}

int256 constant WAD = 1e18;

struct Position {
    int256 size;          // 正ならロング、負ならショート。単位は対象資産数量
    uint256 margin;       // このポジションに預けた証拠金
    uint256 entryPrice;   // 建玉時のマーク価格
    int256 entryFunding;  // 建玉時の累積ファンディング指数。次節参照
}

/// 未実現損益：符号付きsizeによりロングとショートを一行で扱う
function unrealizedPnl(Position memory p, uint256 mark) pure returns (int256) {
    return p.size * (int256(mark) - int256(p.entryPrice)) / WAD;
}

/// 想定元本 = ポジションの絶対数量 × マーク価格
function notional(Position memory p, uint256 mark) pure returns (uint256) {
    int256 s = p.size >= 0 ? p.size : -p.size;
    return uint256(s) * mark / uint256(WAD);
}

int256 public cumulativeFunding;  // ロング一単位あたりの累積支払額。符号付き
uint256 public lastFundingAt;

/// 前回から現在までのファンディングを指数に積算する。O(1)で建玉数に依存しない
function accrueFunding(uint256 mark, uint256 index) internal {
    uint256 elapsed = block.timestamp - lastFundingAt;
    if (elapsed == 0) return;

    // プレミアム項：マーク価格と指数価格の偏差をWAD倍する
    int256 premium = (int256(mark) - int256(index)) * WAD / int256(index);

    // 料率 = プレミアムを秒あたりに配分 + 金利項。必ず上下限内に収める
    int256 rate = premium / int256(fundingPeriod) + interestPerSecond;
    if (rate > fundingCapPerSecond) rate = fundingCapPerSecond;
    if (rate < -fundingCapPerSecond) rate = -fundingCapPerSecond;

    cumulativeFunding += rate * int256(elapsed) * int256(index) / WAD;
    lastFundingAt = block.timestamp;
}

/// 支払うファンディング：正なら支払い、負なら受け取り
function fundingOwed(Position memory p, int256 cumulative) pure returns (int256) {
    return p.size * (cumulative - p.entryFunding) / WAD;
}

/// 純資産 = 証拠金 + 未実現損益 − 支払うファンディング
function equity(Position memory p, uint256 mark, int256 cumulative) pure returns (int256) {
    return int256(p.margin) + unrealizedPnl(p, mark) - fundingOwed(p, cumulative);
}

error NotLiquidatable();

/// 清算可能条件：純資産が維持必要額以下になる
function isLiquidatable(
    Position memory p,
    uint256 mark,
    int256 cumulative,
    uint256 maintenanceBps    // 維持証拠金率。典型的には数十から数百bps。通常は規模別に段階設定し、必ず変更可能にする
) pure returns (bool) {
    int256 e = equity(p, mark, cumulative);
    if (e <= 0) return true;
    return uint256(e) <= notional(p, mark) * maintenanceBps / BPS;
}

function liquidate(address trader) external {
    Position storage p = positions[trader];
    uint256 mark = markPrice();
    accrueFunding(mark, priceGuard.readPrice());          // 先にファンディングを精算してから判定する

    if (!isLiquidatable(p, mark, cumulativeFunding, maintenanceBps)) revert NotLiquidatable();

    int256 e = equity(p, mark, cumulativeFunding);
    uint256 fee = notional(p, mark) * liquidationFeeBps / BPS;   // 清算者が参加する動機のすべて

    if (e > int256(fee)) {
        _payout(msg.sender, fee);                  // 清算者に手数料を払う
        _payout(trader, uint256(e) - fee);         // 残りを利用者に返す
    } else if (e > 0) {
        _payout(msg.sender, uint256(e));           // 手数料の一部しか払えない
    } else {
        // 純資産が負：証拠金超過損失。この取引内で不足を負担する主体を決める
        _coverShortfall(uint256(-e));
    }

    _closePosition(trader);
}

function _coverShortfall(uint256 gap) internal {
    emit ShortfallCovered(gap);
    if (insuranceFund >= gap) {
        insuranceFund -= gap;
        return;
    }
    uint256 remaining = gap - insuranceFund;
    insuranceFund = 0;
    _autoDeleverage(remaining);      // 利益とレバレッジで順位を付け、利益側を一部強制決済する
}