DeFi 清算風險量化計算完整指南：從理論公式到實例驗算

摘要

去中心化金融（DeFi）清算機制的數學基礎是理解借貸協議風險的核心。本文提供完整的清算風險量化計算框架，包含健康因子、擔保率、清算閾值的數學推導，以及 Aave V3、Compound V3、MakerDAO 等主流協議的實際計算範例。透過詳盡的 Python 程式碼範例，讀者可實際驗證理論公式的正確性，並建立自己的清算風險監控系統。

1. 清算機制的數學基礎

1.1 核心概念定義

在深入計算之前，我們需要明確定義所有核心概念：

抵押品（Collateral）：借款人存入借貸協議的資產，作為借款的擔保。

借款價值（Borrow Value）：借款人從協議中借入資產的當前美元價值。

抵押品價值（Collateral Value）：借款人抵押資產的當前美元價值。

擔保率（Collateral Factor / Loan-to-Value Ratio）：協議允許借款人借入的最高價值與抵押品價值的比率。

清算閾值（Liquidation Threshold）：觸發清算的擔保率臨界值，通常低於初始擔保率。

健康因子（Health Factor）：衡量借款人帳戶健康狀況的綜合指標。

1.2 基本公式推導

1.2.1 擔保率（Collateral Factor）

CF = Borrow_Value / Collateral_Value

或

CF = (Borrow_Amount × Asset_Price) / (Collateral_Amount × Collateral_Price)

合法範圍：0 ≤ CF ≤ 1.0

• CF = 0：無借款
• CF = 1.0：理論最大借款（實際不可達）

實際最大借款計算：

Max_Borrow_Value = Collateral_Amount × Collateral_Price × Collateral_Factor

1.2.2 健康因子（Health Factor）

健康因子是清算觸發的核心判斷標準：

HF = (Σ(Collateral_i × Price_i × LT_i)) / (Σ(Borrow_j × Price_j))

其中：
- HF = 健康因子
- Collateral_i = 第 i 種抵押品的數量
- Price_i = 第 i 種抵押品的美元價格
- LT_i = 第 i 種抵押品的清算閾值（小數形式，如 0.825）
- Borrow_j = 第 j 種借款的數量
- Price_j = 第 j 種借款資產的美元價格

清算觸發條件：HF < 1.0

1.3 清算獎勵計算

當清算被觸發時，清算人可獲得的抵押品數量：

Liquidation_Bonus = Borrowed_Amount × (1 + Liquidation_Bonus_Rate)

Close_Factor = 可清算的最大借款比例（通常是 50%）

2. Aave V3 清算計算深度分析

2.1 Aave V3 參數系統

Aave V3 是以太坊生態系統中最重要的借貸協議之一，其清算機制設計精巧：

關鍵參數：

2.2 健康因子公式（Aave V3）

Aave V3 的健康因子計算比基本公式更為精確：

def calculate_aave_health_factor(
    collateral_reserves: dict,
    borrows: dict,
    current_prices: dict,
    reserve_data: dict
) -> float:
    """
    計算 Aave V3 健康因子
    
    參數:
        collateral_reserves: {asset: amount}
        borrows: {asset: amount}
        current_prices: {asset: price_in_usd}
        reserve_data: {asset: {"liquidationThreshold": lt, "liquidationBonus": lb}}
    
    返回:
        健康因子
    """
    # 計算總抵押品加權價值
    total_collateral_weighted = 0.0
    for asset, amount in collateral_reserves.items():
        price = current_prices.get(asset, 0)
        lt = reserve_data[asset]["liquidationThreshold"] / 10000.0  # 基點轉換
        total_collateral_weighted += amount * price * lt
    
    # 計算總借款價值
    total_borrow_value = 0.0
    for asset, amount in borrows.items():
        price = current_prices.get(asset, 0)
        total_borrow_value += amount * price
    
    # 健康因子
    if total_borrow_value == 0:
        return float('inf')  # 無借款時為無窮大
    
    health_factor = total_collateral_weighted / total_borrow_value
    return health_factor

2.3 實例計算：單一抵押品、單一借款

場景設定：

• 抵押品：10 ETH，價值 $3,500/ETH = $35,000
• ETH 的清算閾值：82.5%（Aave V3 預設）
• 借款：20,000 USDC，價值 $1/個 = $20,000
• USDC 的清算獎勵：8%（Aave V3 預設）

步驟 1：計算健康因子

HF = (10 ETH × $3,500 × 0.825) / (20,000 USDC × $1)
HF = ($28,875) / ($20,000)
HF = 1.44375

步驟 2：判斷是否觸發清算

HF = 1.44375 > 1.0
結論：未觸發清算，帳戶健康

步驟 3：計算最大安全借款

Max_Borrow = 10 ETH × $3,500 × 0.825 = $28,875
Current_Borrow = $20,000
Safe_Borrow_Room = $8,875

2.4 實例計算：單一抵押品、單一借款（清算邊緣）

場景設定：

• 抵押品：10 ETH，價值 $3,500/ETH = $35,000
• ETH 的清算閾值：82.5%
• 借款：28,000 USDC，價值 $1/個 = $28,000
• USDC 的清算獎勵：8%

步驟 1：計算健康因子

HF = (10 ETH × $3,500 × 0.825) / (28,000 USDC × $1)
HF = ($28,875) / ($28,000)
HF = 1.03125

步驟 2：判斷是否觸發清算

HF = 1.03125 > 1.0
結論：仍未觸發清算，但已接近臨界值

步驟 3：計算觸發清算的價格

HF = 1.0 時：
(10 ETH × Price × 0.825) / (28,000 × $1) = 1.0
Price = 28,000 / (10 × 0.825)
Price = $3,393.94

結論：當 ETH 價格低於 $3,393.94 時，觸發清算

步驟 4：驗證計算

# Python 驗證
ETH_AMOUNT = 10
ETH_PRICE = 3500
LT_ETH = 0.825
USDC_BORROW = 28000
USDC_PRICE = 1.0

health_factor = (ETH_AMOUNT * ETH_PRICE * LT_ETH) / (USDC_BORROW * USDC_PRICE)
print(f"健康因子: {health_factor:.4f}")  # 輸出: 1.0312

# 計算觸發清算的 ETH 價格
# 1.0 = (10 * trigger_price * 0.825) / 28000
trigger_price = 28000 / (10 * 0.825)
print(f"清算觸發價格: ${trigger_price:.2f}")  # 輸出: $3393.94

2.5 實例計算：清算發生

場景設定：

ETH 價格下跌至 $3,300，觸發清算

步驟 1：重新計算健康因子

HF = (10 ETH × $3,300 × 0.825) / (28,000 USDC × $1)
HF = ($27,225) / ($28,000)
HF = 0.97232

步驟 2：確認清算觸發

HF = 0.97232 < 1.0
結論：清算已觸發

步驟 3：計算清算量

清算人可清算最多 50%（close factor）的借款：

Max_Liquidation = 28,000 USDC × 0.5 = 14,000 USDC

步驟 4：計算清算人獲得的 ETH

清算獎勵為 8%，所以清算人以折扣價獲得 ETH：

Liquidation_Bonus = 1.08
Debt_Covered = 14,000 USDC

ETH_To_Liquidator = (14,000 / $3,300) × 1.08
ETH_To_Liquidator = 4.2424 × 1.08
ETH_To_Liquidator = 4.5818 ETH

步驟 5：借款人剩餘狀態

清算後：
- 借款人 ETH：10 - 4.5818 = 5.4182 ETH
- 借款人 USDC：28,000 - 14,000 = 14,000 USDC（待還款）
- 借款人 ETH 價值：5.4182 × $3,300 = $17,880.06
- 新健康因子：(5.4182 × $3,300 × 0.825) / ($14,000 × $1)
           = ($14,732.92) / ($14,000)
           = 1.05235

2.6 實例計算：多資產組合

場景設定：

借款人同時持有 ETH 和 WBTC 作為抵押品：

借款：

步驟 1：計算總抵押品加權價值

ETH_Weighted = 10 × $3,300 × 0.825 = $27,225
WBTC_Weighted = 0.5 × $70,000 × 0.70 = $24,500
Total_Weighted = $51,725

步驟 2：計算總借款價值

USDC_Borrow = 50,000 × $1.00 = $50,000
ETH_Borrow = 5 × $3,300 = $16,500
Total_Borrow = $66,500

步驟 3：計算健康因子

HF = $51,725 / $66,500 = 0.778

步驟 4：清算分析

HF < 1.0，觸發清算

最大清算量（50% 借款）= $66,500 × 0.5 = $33,250

清算人會優先清算高獎勵資產，假設先清算 USDC 借款：
清算 USDC = $33,250
獲得抵押品 = $33,250 × 1.08 = $35,910

ETH 清算：(假設清算獎勵 5%)
清算 ETH = $0（由 USDC 清算覆蓋）

最終狀態需重新計算 HF

3. Compound V3 清算計算深度分析

3.1 Compound V3 的設計特點

Compound V3（Compound III）與 V2 有顯著不同：

• 單一抵押品模式：用戶只能選擇一種資產作為抵押品
• 資產隔離：不同市場相互隔離
• 自動化利率：無需手動借款利率調整

3.2 Compound V3 健康因子公式

def calculate_compound_v3_health_factor(
    collateral_amount: float,
    collateral_price: float,
    borrow_amount: float,
    borrow_price: float,
    collateral_factor: float,
    liquidation_threshold: float
) -> float:
    """
    Compound V3 健康因子計算
    
    Compound V3 使用較簡化的公式：
    HF = (Collateral × CF) / Borrow
    """
    collateral_value = collateral_amount * collateral_price
    borrow_value = borrow_amount * borrow_price
    
    if borrow_value == 0:
        return float('inf')
    
    # Compound V3 使用 collateral factor 而非 liquidation threshold
    health_factor = (collateral_value * collateral_factor) / borrow_value
    return health_factor

3.3 Compound V3 vs Aave V3 比較

4. MakerDAO 清算計算深度分析

4.1 MakerDAO 的 CDP（Collateralized Debt Position）

MakerDAO 是以太坊最早的去中心化借貸協議，其清算機制稱為「清算」（Liquidation）或「拍賣」（Auction）：

關鍵術語：

4.2 MakerDAO 清算比率計算

def calculate_makerdao_collateral_ratio(
    collateral_amount: float,
    collateral_price: float,
    debt_dai: float,
    liquidation_ratio: float
) -> dict:
    """
    MakerDAO Vault 健康狀況計算
    """
    collateral_value = collateral_amount * collateral_price
    collateral_ratio = collateral_value / debt_dai
    
    return {
        "collateral_value": collateral_value,
        "debt_dai": debt_dai,
        "collateral_ratio": collateral_ratio,
        "liquidation_ratio": liquidation_ratio,
        "is_healthy": collateral_ratio > liquidation_ratio,
        "liquidation_price": (debt_dai * liquidation_ratio) / collateral_amount,
        "safety_margin": (collateral_ratio - liquidation_ratio) / liquidation_ratio * 100
    }

4.3 實例計算：MakerDAO Vault

場景設定：

• 抵押品：15 ETH @ $3,300 = $49,500
• 借款：25,000 DAI
• 清算比率：145%（MakerDAO 預設）

步驟 1：計算抵押率

抵押率 = $49,500 / 25,000 DAI = 1.98 = 198%

步驟 2：判斷清算觸發

抵押率 198% > 清算比率 145%
結論：Vault 健康，未觸發清算

步驟 3：計算清算觸發價格

清算觸發價格 = (借款 DAI × 清算比率) / ETH 數量
            = (25,000 × 1.45) / 15
            = 36,250 / 15
            = $2,416.67

步驟 4：計算安全邊際

安全邊際 = (抵押率 - 清算比率) / 清算比率
        = (1.98 - 1.45) / 1.45
        = 0.53 / 1.45
        = 36.55%

這意味著 ETH 可以下跌 36.55% 才會觸發清算

步驟 5：清算觸發後計算

假設 ETH 價格下跌至 $2,400：

抵押率 = (15 × $2,400) / 25,000 = 1.44 = 144%
1.44 < 1.45，觸發清算

MakerDAO 拍賣機制：

MakerDAO 使用荷蘭式拍賣：

拍賣開始：抵押品以高溢價開始
時間流逝：價格逐漸降低
達到市價：有人購買
結算完成：借款人獲得剩餘抵押品（若有）

5. 清算風險的波動性分析

5.1 波動性對清算觸發的影響

清算風險與資產價格波動性密切相關。我們使用歷史波動率來估算清算觸發概率：

import math
from scipy import stats

def calculate_liquidation_probability(
    current_price: float,
    liquidation_price: float,
    volatility: float,
    time_to_expiry: float
) -> float:
    """
    使用 Black-Scholes 模型估算清算觸發概率
    
    假設價格遵循幾何布朗運動：
    dS = μS dt + σS dW
    
    參數:
        current_price: 當前資產價格
        liquidation_price: 清算觸發價格
        volatility: 年化波動率
        time_to_expiry: 時間（年）
    """
    # 轉換為對數收益率
    # P(S(T) < K) = N(-d2)
    
    d2 = (math.log(current_price / liquidation_price) + 
          (0.5 * volatility**2) * time_to_expiry) / \
         (volatility * math.sqrt(time_to_expiry))
    
    probability = stats.norm.cdf(-d2)
    return probability

# 實例計算
# ETH 現價 $3,300，清算價格 $2,400，年化波動率 80%，30 天內清算概率
prob_30d = calculate_liquidation_probability(
    current_price=3300,
    liquidation_price=2400,
    volatility=0.80,
    time_to_expiry=30/365
)
print(f"30天內清算概率: {prob_30d:.2%}")  # 輸出約 14.7%

# 90 天內清算概率
prob_90d = calculate_liquidation_probability(
    current_price=3300,
    liquidation_price=2400,
    volatility=0.80,
    time_to_expiry=90/365
)
print(f"90天內清算概率: {prob_90d:.2%}")  # 輸出約 26.5%

5.2 模擬分析：蒙特卡羅模擬

import numpy as np
import matplotlib.pyplot as plt

def monte_carlo_liquidation_simulation(
    initial_price: float,
    collateral_value: float,
    debt_value: float,
    liquidation_ratio: float,
    volatility: float,
    num_simulations: int = 10000,
    days: int = 30
) -> dict:
    """
    蒙特卡羅模擬清算風險
    
    返回:
        模擬路徑、清算概率、VaR 等
    """
    dt = 1 / 365  # 每日時間步長
    num_steps = days
    
    # 生成模擬路徑
    paths = np.zeros((num_simulations, num_steps + 1))
    paths[:, 0] = initial_price
    
    # 幾何布朗運動參數
    mu = 0  # 漂移率（假設為零）
    
    for t in range(1, num_steps + 1):
        z = np.random.standard_normal(num_simulations)
        paths[:, t] = paths[:, t-1] * np.exp(
            (mu - 0.5 * volatility**2) * dt + 
            volatility * np.sqrt(dt) * z
        )
    
    # 計算清算觸發價格
    liquidation_price = (debt_value * liquidation_ratio) / collateral_value * debt_value / collateral_value * initial_price
    
    # 重新計算：更準確的公式
    # 假設初始 HF = 抵押率 / 清算比率
    initial_collateral_ratio = collateral_value / debt_value
    liquidation_collateral_ratio = liquidation_ratio
    
    # 清算時抵押品數量 = debt * ratio / current_price
    # 所以清算價格 = debt * ratio / collateral_amount
    
    # 假設抵押品數量固定：
    collateral_amount = collateral_value / initial_price
    liquidation_price = (debt_value * liquidation_ratio) / collateral_amount
    
    # 統計清算次數
    liquidation_hits = np.any(paths < liquidation_price, axis=1)
    liquidation_probability = np.mean(liquidation_hits)
    
    # 計算 VaR
    returns = (paths[:, -1] - initial_price) / initial_price
    var_95 = np.percentile(returns, 5)
    var_99 = np.percentile(returns, 1)
    
    return {
        "paths": paths,
        "liquidation_price": liquidation_price,
        "liquidation_probability": liquidation_probability,
        "var_95": var_95,
        "var_99": var_99,
        "expected_price": np.mean(paths[:, -1]),
        "median_price": np.median(paths[:, -1])
    }

# 實例模擬
result = monte_carlo_liquidation_simulation(
    initial_price=3300,
    collateral_value=49500,  # 15 ETH
    debt_value=25000,        # 25000 DAI
    liquidation_ratio=1.45,
    volatility=0.80,
    num_simulations=50000,
    days=30
)

print(f"清算觸發價格: ${result['liquidation_price']:.2f}")
print(f"30天清算概率: {result['liquidation_probability']:.2%}")
print(f"VaR (95%): {result['var_95']:.2%}")
print(f"VaR (99%): {result['var_99']:.2%}")

5.3 壓力測試：極端市場情境

def stress_test_liquidation(
    collateral_type: str,
    collateral_amount: float,
    debt_amount: float,
    scenarios: dict
) -> pd.DataFrame:
    """
    清算風險壓力測試
    
    scenarios: {
        "情境名稱": {
            "price_change": -0.50,  # 價格變動百分比
            "volatility_spike": 2.0,  # 波動率倍數
        }
    }
    """
    results = []
    
    for scenario_name, params in scenarios.items():
        price_multiplier = 1 + params.get("price_change", 0)
        vol_multiplier = params.get("volatility_spike", 1.0)
        
        # 假設 ETH 初始價格 $3,300
        initial_price = 3300
        current_price = initial_price * price_multiplier
        
        collateral_value = collateral_amount * current_price
        
        # 計算抵押率（假設 MakerDAO 清算比率 145%）
        liquidation_ratio = 1.45
        collateral_ratio = collateral_value / debt_amount
        
        # 健康狀態
        is_healthy = collateral_ratio >= liquidation_ratio
        
        # 安全邊際
        if collateral_ratio > 0:
            safety_margin = (collateral_ratio - liquidation_ratio) / liquidation_ratio
        else:
            safety_margin = float('inf')
        
        results.append({
            "scenario": scenario_name,
            "price_change": params.get("price_change", 0),
            "new_price": current_price,
            "collateral_value": collateral_value,
            "collateral_ratio": collateral_ratio,
            "liquidation_ratio": liquidation_ratio,
            "is_healthy": is_healthy,
            "safety_margin": safety_margin,
            "price_drawdown_to_liquidation": 1 - (liquidation_ratio * debt_amount) / collateral_value
        })
    
    return pd.DataFrame(results)

# 執行壓力測試
scenarios = {
    "正常市場": {"price_change": 0, "volatility_spike": 1.0},
    "溫和下跌 -20%": {"price_change": -0.20, "volatility_spike": 1.5},
    "顯著下跌 -40%": {"price_change": -0.40, "volatility_spike": 2.0},
    "劇烈下跌 -50%": {"price_change": -0.50, "volatility_spike": 3.0},
    "極端情境 -60%": {"price_change": -0.60, "volatility_spike": 4.0},
}

results_df = stress_test_liquidation(
    collateral_type="ETH",
    collateral_amount=15,  # 15 ETH
    debt_amount=25000,     # 25000 DAI
    scenarios=scenarios
)

print(results_df.to_string(index=False))

6. 清算機器人的數學基礎

6.1 清算利潤計算

清算機器人的核心是計算清算機會的利潤：

def calculate_liquidation_profit(
    debt_amount: float,
    debt_price: float,
    collateral_amount: float,
    collateral_price: float,
    liquidation_bonus: float,
    gas_cost_usd: float,
    eth_price: float
) -> dict:
    """
    計算清算利潤
    """
    # 清算人需要償還的債務
    debt_value = debt_amount * debt_price
    
    # 清算人獲得的抵押品（包含獎勵）
    collateral_received = collateral_amount * (1 + liquidation_bonus)
    collateral_value_at_market = collateral_received * collateral_price
    
    # 總利潤（未扣 Gas）
    gross_profit = collateral_value_at_market - debt_value
    
    # 淨利潤（扣除 Gas）
    # Gas 成本以 ETH 計算，需轉換為 USD
    gas_cost_eth = gas_cost_usd / eth_price
    
    net_profit = gross_profit - gas_cost_eth
    
    # 利潤率
    profit_margin = gross_profit / debt_value if debt_value > 0 else 0
    
    # ROI（假設每筆交易使用 X ETH 作為流動性）
    capital_required = debt_value  # 清算人需要準備這麼多流動性
    roi = net_profit / capital_required if capital_required > 0 else 0
    
    return {
        "gross_profit_usd": gross_profit,
        "net_profit_usd": net_profit,
        "gas_cost_eth": gas_cost_eth,
        "profit_margin": profit_margin,
        "roi_per_trade": roi,
        "is_profitable": net_profit > 0
    }

6.2 實例計算：清算利潤

場景設定：

• 清算人償還：14,000 USDC
• 獲得抵押品：4.3 ETH（含 8% 獎勵）
• ETH 市場價格：$3,300
• Gas 成本：0.02 ETH（約 $66）

步驟 1：基礎計算

清算人需要償還的 USDC：14,000 × $1.00 = $14,000
清算人獲得的 ETH：4.3 ETH
ETH 市場價值：4.3 × $3,300 = $14,190

步驟 2：利潤計算

毛利潤 = $14,190 - $14,000 = $190
Gas 成本 = 0.02 ETH × $3,300 = $66
淨利潤 = $190 - $66 = $124

步驟 3：ROI 計算

所需流動性 = $14,000
單筆 ROI = $124 / $14,000 = 0.886%

假設每小時可執行 5 筆清算（理想條件）：
年化 ROI = 0.886% × 5 × 24 × 365 = 38,800%（理論值）

6.3 最優清算量計算

def find_optimal_liquidation_amount(
    max_borrow: float,
    close_factor: float,
    collateral_price: float,
    liquidation_price: float,
    liquidation_bonus: float,
    gas_cost_usd: float,
    eth_price: float,
    min_profit_threshold: float = 10.0
) -> dict:
    """
    找到最優清算量
    """
    results = []
    
    for close_pct in [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]:
        liquidation_amount = max_borrow * close_pct
        
        # 計算需要的抵押品（假設抵押品數量等於借款價值 / 抵押品價格）
        # 這是簡化計算，實際需要根據借款人的抵押品結構
        collateral_amount = liquidation_amount / liquidation_price
        
        # 清算人獲得的抵押品（含獎勵）
        collateral_received = collateral_amount * (1 + liquidation_bonus)
        
        # 利潤計算
        profit = calculate_liquidation_profit(
            debt_amount=liquidation_amount / collateral_price,  # 假設 1:1
            debt_price=1.0,
            collateral_amount=collateral_received,
            collateral_price=collateral_price,
            liquidation_bonus=0,
            gas_cost_usd=gas_cost_usd,
            eth_price=eth_price
        )
        
        results.append({
            "close_pct": close_pct,
            "liquidation_amount_usd": liquidation_amount,
            "profit_usd": profit["net_profit_usd"],
            "is_viable": profit["net_profit_usd"] >= min_profit_threshold
        })
    
    return pd.DataFrame(results)

7. 清算風險管理最佳實踐

7.1 借款人風險管理

原則 1：維持足夠的安全邊際

建議：HF 應始終維持在 2.0 以上
原因：防止短期波動觸發清算

原則 2：分散抵押品類型

避免：單一資產抵押
建議：多資產組合，降低相關性

原則 3：動態監控與預警

def calculate_liquidation_distance(
    collateral_amount: float,
    collateral_price: float,
    collateral_lt: float,
    borrow_amount: float,
    borrow_price: float
) -> dict:
    """
    計算距離清算的空間
    """
    # 當前 HF
    current_hf = (collateral_amount * collateral_price * collateral_lt) / \
                 (borrow_amount * borrow_price)
    
    # HF = 1.0 時的抵押品價格
    hf1_collateral_price = (borrow_amount * borrow_price) / \
                          (collateral_amount * collateral_lt)
    
    # 價格下跌空間
    price_drop_to_liquidation = (collateral_price - hf1_collateral_price) / \
                                  collateral_price
    
    return {
        "current_hf": current_hf,
        "liquidation_price": hf1_collateral_price,
        "price_drop_pct": price_drop_to_liquidation,
        "safety_margin": current_hf - 1.0
    }

7.2 清算人風險管理

原則 1：Gas 成本優化

要點：清算利潤必須大於 Gas 成本
建議：批量處理多個清算以攤薄固定成本

原則 2：區塊重組風險

要點：MEV 可能導致交易失敗
建議：使用 Flashbots Protect 等服務

原則 3：價格預言機風險

要點：依賴預言機餵價
建議：監控預言機偏差，設置緩衝

7.3 協議層面風險控制

8. 結論與計算摘要

8.1 核心公式總結

8.2 主要協議參數

8.3 Python 驗算要點

# 健康因子驗算
HF = (collateral_amount * price * liquidation_threshold) / \
     (borrow_amount * borrow_price)

# 清算觸發價格
liquidation_price = (borrow_amount * borrow_price) / \
                    (collateral_amount * liquidation_threshold)

# 清算利潤
profit = (collateral_received * collateral_price) - \
         (debt_paid * debt_price) - gas_cost

第九章：MEV 獎勵分配與清算觸發時序模擬

9.1 MEV 獎勵分配的量化分析

9.1.1 MEV（最大可提取價值）概述

MEV（Miner Extractable Value，最大可提取價值）是區塊建構者從交易排序中獲取的利潤。在 DeFi 借貸協議中，MEV 與清算機制緊密相關——清算人透過搶先交易（Front-running）被捕獲的清算機會來獲取利潤。

MEV 的主要類型

┌─────────────────────────────────────────────────────────────────┐
│                      MEV 類型分類                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   ┌───────────────┐   ┌───────────────┐   ┌───────────────┐   │
│   │   套利        │   │   清算        │   │   三明治攻擊  │   │
│   │   Arbitrage   │   │   Liquidation │   │   Sandwich    │   │
│   └───────────────┘   └───────────────┘   └───────────────┘   │
│         │                   │                   │               │
│         ▼                   ▼                   ▼               │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                                                         │   │
│   │   DEX 報價差異 → 低買高賣 → 利潤 = 差價 × 數量        │   │
│   │                                                         │   │
│   │   抵押品健康因子 < 1 → 觸發清算 → 清算獎勵            │   │
│   │                                                         │   │
│   │   大額交易 → 滑點 → 前後夾擊 → 利潤 = 滑點 × 數量     │   │
│   │                                                         │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

9.1.2 清算 MEV 的獎勵分配模型

清算 MEV 的獎勵在以下角色之間分配：

┌─────────────────────────────────────────────────────────────────┐
│                  清算 MEV 獎勵分配流程                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   清算觸發時的價值流動：                                        │
│                                                                 │
│   ┌──────────────┐                                              │
│   │  借款人      │ ← 抵押品減少                                 │
│   │  (被清算)    │                                              │
│   └──────┬───────┘                                              │
│          │                                                       │
│          ▼                                                       │
│   ┌──────────────┐                                              │
│   │  清算人      │ ← 獲得抵押品 - 償還債務 + 獎勵               │
│   │ (Liquidator) │                                              │
│   └──────┬───────┘                                              │
│          │                                                       │
│          ├── MEV-Boost ──┬──▶ 區塊構建者 (60-70%)              │
│          │                │                                      │
│          │                └──▶ 提議者/驗證者 (30-40%)            │
│          │                                                       │
│          └── Flashbots ──▶搜尋者/搜尋機器人收益                 │
│                                                                 │
│   典型分配比例（2026年第一季度）：                               │
│                                                                 │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │   角色           │   分配比例    │   說明              │   │
│   ├─────────────────────────────────────────────────────────┤   │
│   │   區塊構建者     │   30-40%      │   包含交易、排序     │   │
│   │   提議者/驗證者 │   10-20%      │   區塊獎勵分成       │   │
│   │   搜尋者/機器人 │   40-60%      │   策略執行者收益     │   │
│   │   Gas 費用      │   可變        │   網路使用費         │   │
│   └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

9.1.3 MEV 獎勵量化計算模型

def calculate_mev_liquidation_reward_distribution(
    # 基礎參數
    collateral_amount: float,         # 抵押品數量（ETH）
    collateral_price: float,          # 抵押品價格（USD）
    debt_amount: float,               # 債務數量（USDC）
    liquidation_bonus: float,         # 清算獎勵率（如 0.08）
    
    # MEV 相關參數
    mev_extracted: float,             # 提取的 MEV 總值
    searcher_share: float,            # 搜尋者份額（如 0.65）
    builder_share: float,             # 構建者份額（如 0.25）
    proposer_share: float,            # 提議者份額（如 0.10）
    
    # 成本參數
    gas_cost_eth: float,              # Gas 成本（ETH）
    eth_price: float,                 # ETH 價格（USD）
    
    # 其他
    protocol_fee: float = 0.0        # 協議費用（如有的話）
) -> dict:
    """
    計算清算 MEV 獎勵的完整分配
    """
    # 1. 清算人基礎收益計算
    debt_value = debt_amount  # 假設 USDC = 1 USD
    collateral_received = collateral_amount * (1 + liquidation_bonus)
    collateral_gross_value = collateral_received * collateral_price
    
    # 清算人毛利潤
    gross_profit = collateral_gross_value - debt_value - (gas_cost_eth * eth_price)
    
    # 2. MEV 提取量計算
    # 清算產生的總 MEV = 清算獎勵 - 正常市場價值差異
    normal_collateral_value = collateral_amount * collateral_price
    mev_value = collateral_gross_value - normal_collateral_value
    
    # 3. MEV 分配
    searcher_profit = mev_extracted * searcher_share
    builder_profit = mev_extracted * builder_share
    proposer_profit = mev_extracted * proposer_share
    
    # 4. 完整收益表
    total_extracted = debt_value + mev_value + (gas_cost_eth * eth_price)
    
    return {
        # 抵押品流向
        "liquidator_collateral_received_eth": collateral_received,
        "liquidator_collateral_value_usd": collateral_gross_value,
        
        # 清算人收益
        "liquidator_gross_profit_usd": gross_profit + mev_value,
        "liquidator_gas_cost_usd": gas_cost_eth * eth_price,
        "liquidator_net_profit_usd": gross_profit + mev_value - protocol_fee,
        
        # MEV 分配
        "total_mev_extracted_usd": mev_extracted,
        "searcher_share_usd": searcher_profit,
        "builder_share_usd": builder_profit,
        "proposer_share_usd": proposer_profit,
        
        # 百分比分配
        "searcher_share_pct": searcher_share * 100,
        "builder_share_pct": builder_share * 100,
        "proposer_share_pct": proposer_share * 100,
        
        # 總結算
        "total_settlement_usd": total_extracted
    }

# 實例計算
result = calculate_mev_liquidation_reward_distribution(
    collateral_amount=10.0,           # 10 ETH
    collateral_price=3300.0,          # $3300/ETH
    debt_amount=28000.0,             # 28000 USDC
    liquidation_bonus=0.08,           # 8% 獎勵
    mev_extracted=5000.0,             # 提取了 $5000 MEV
    searcher_share=0.65,              # 搜尋者 65%
    builder_share=0.25,              # 構建者 25%
    proposer_share=0.10,             # 提議者 10%
    gas_cost_eth=0.05,                # 0.05 ETH Gas
    eth_price=3300.0                  # $3300/ETH
)

print("=== 清算 MEV 獎勵分配報告 ===")
print(f"\n【抵押品流向】")
print(f"  清算人獲得 ETH: {result['liquidator_collateral_received_eth']:.4f} ETH")
print(f"  抵押品美元價值: ${result['liquidator_collateral_value_usd']:,.2f}")

print(f"\n【清算人收益】")
print(f"  總利潤: ${result['liquidator_gross_profit_usd']:,.2f}")
print(f"  Gas 成本: ${result['liquidator_gas_cost_usd']:,.2f}")
print(f"  淨利潤: ${result['liquidator_net_profit_usd']:,.2f}")

print(f"\n【MEV 分配】")
print(f"  總 MEV: ${result['total_mev_extracted_usd']:,.2f}")
print(f"  搜尋者: ${result['searcher_share_usd']:,.2f} ({result['searcher_share_pct']:.1f}%)")
print(f"  構建者: ${result['builder_share_usd']:,.2f} ({result['builder_share_pct']:.1f}%)")
print(f"  提議者: ${result['proposer_share_usd']:,.2f} ({result['proposer_share_pct']:.1f}%)")

9.1.4 清算利潤的敏感度分析

def liquidation_profit_sensitivity_analysis(
    collateral_price: float,
    liquidation_price: float,
    debt_amount: float,
    liquidation_bonus: float = 0.08,
    gas_cost_usd: float = 100.0
) -> pd.DataFrame:
    """
    清算利潤對不同因素的敏感度分析
    """
    results = []
    
    # 不同抵押品價格的敏感度
    for price_pct in [0.8, 0.85, 0.9, 0.95, 1.0, 1.05, 1.1, 1.15, 1.2]:
        price = collateral_price * price_pct
        collateral_value = price  # 假設 1 ETH
        
        # 健康因子
        hf = collateral_value / liquidation_price
        
        # 清算獎勵
        bonus_value = collateral_value * liquidation_bonus
        
        # 利潤
        gross_profit = bonus_value - gas_cost_usd
        profit_per_dollar = gross_profit / debt_amount if debt_amount > 0 else 0
        
        results.append({
            "scenario": f"價格={price:.0f}",
            "price_pct": f"{price_pct*100:.0f}%",
            "collateral_value": collateral_value,
            "health_factor": hf,
            "bonus_value": bonus_value,
            "gross_profit": gross_profit,
            "profit_per_10k": profit_per_dollar * 10000,
            "is_profitable": gross_profit > 0
        })
    
    return pd.DataFrame(results)

# 執行敏感度分析
sensitivity = liquidation_profit_sensitivity_analysis(
    collateral_price=3300.0,      # 現價 $3300
    liquidation_price=2800.0,      # 清算觸發價 $2800
    debt_amount=2800.0,           # 對應債務
    liquidation_bonus=0.08,
    gas_cost_usd=100.0
)

print("\n=== 清算利潤敏感度分析 ===")
print(sensitivity.to_string(index=False))

9.2 清算觸發條件的時序模擬

9.2.1 清算觸發的時序流程

清算觸發並非瞬間完成，而是經過多個步驟的複雜時序過程：

┌─────────────────────────────────────────────────────────────────┐
│                  清算觸發時序模擬                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   T₀ = 某區塊時間戳                                            │
│                                                                 │
│   ┌──────────────────────────────────────────────────────────┐   │
│   │  T₀-5s    價格預言機更新                                 │   │
│   │           假設：ETH 價格 $3,300 → $3,200                │   │
│   │           (下跌 $100, 跌幅 3.03%)                        │   │
│   └──────────────────────┬─────────────────────────────────┘   │
│                          │                                      │
│                          ▼                                      │
│   ┌──────────────────────────────────────────────────────────┐   │
│   │  T₀-3s    抵押品健康因子重新計算                          │   │
│   │                                                            │   │
│   │   HF_old = (1 ETH × $3,300 × 0.825) / $2,722.50          │   │
│   │         = 1.0000                                          │   │
│   │                                                            │   │
│   │   HF_new = (1 ETH × $3,200 × 0.825) / $2,722.50          │   │
│   │         = 0.9697 < 1.0  ← 觸發條件滿足                   │   │
│   └──────────────────────┬─────────────────────────────────┘   │
│                          │                                      │
│                          ▼                                      │
│   ┌──────────────────────────────────────────────────────────┐   │
│   │  T₀-2s    搜尋者偵測到清算機會                           │   │
│   │                                                            │   │
│   │   搜尋者持續監控所有借貸協議的狀態                        │   │
│   │   計算每個健康因子 < 1 的帳戶                             │   │
│   │   評估清算利潤                                            │   │
│   │                                                            │   │
│   │   利潤計算：                                              │   │
│   │   - 償還債務：$2,722.50                                   │   │
│   │   - 獲得抵押品：1 ETH × (1 + 8%) = 1.08 ETH              │   │
│   │   - 抵押品價值：1.08 × $3,200 = $3,456                   │   │
│   │   - 毛利潤：$3,456 - $2,722.50 = $733.50                 │   │
│   │   - 扣除 Gas 後：$733.50 - $50 = $683.50 ✓               │   │
│   └──────────────────────┬─────────────────────────────────┘   │
│                          │                                      │
│                          ▼                                      │
│   ┌──────────────────────────────────────────────────────────┐   │
│   │  T₀-1s    搜尋者提交交易到 Flashbots MEV-Boost           │   │
│   │                                                            │   │
│   │   交易結構：                                               │   │
│   │   {                                                        │   │
│   │     "method": "eth_sendBundle",                          │   │
│   │     "params": [{                                         │   │
│   │       "txs": [liquidation_tx],                           │   │
│   │       "blockNumber": "0xABC123",                        │   │
│   │       "minTimestamp": ...,                               │   │
│   │       "maxTimestamp": ...                                │   │
│   │     }]                                                    │   │
│   │   }                                                        │   │
│   └──────────────────────┬─────────────────────────────────┘   │
│                          │                                      │
│                          ▼                                      │
│   ┌──────────────────────────────────────────────────────────┐   │
│   │  T₀        區塊構建者組裝區塊                             │   │
│   │                                                            │   │
│   │   ┌──────────────────────────────────────────────────┐  │   │
│   │   │  區塊構建者從多個 MEV 交易中選擇                    │  │   │
│   │   │                                                   │  │   │
│   │   │  選擇邏輯：                                        │  │   │
│   │   │  1. 按 MEV 利潤排序（貪心演算法）                  │  │   │
│   │   │  2. 檢查交易衝突                                    │  │   │
│   │   │  3. 考慮 Gas 價格                                    │  │   │
│   │   │                                                   │  │   │
│   │   │  本區塊包含：清算交易（$683.50 利潤）              │  │   │
│   │   └──────────────────────────────────────────────────┘  │   │
│   └──────────────────────┬─────────────────────────────────┘   │
│                          │                                      │
│                          ▼                                      │
│   ┌──────────────────────────────────────────────────────────┐   │
│   │  T₀ + 12s  區塊被提議和最終確認                           │   │
│   │                                                            │   │
│   │   清算完成狀態：                                          │   │
│   │   - 借款人 ETH: 0 (全部清算)                              │   │
│   │   - 借款人 USDC: $0 (債務已清)                           │   │
│   │   - 清算人 ETH: +1.08 (包含獎勵)                          │   │
│   │   - 清算人 USDC: -$2,722.50 (償還債務)                   │   │
│   └──────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

9.2.2 清算時序模擬器

import numpy as np
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum

class LiquidationEventType(Enum):
    HEALTH_FACTOR_UPDATE = "健康因子更新"
    SEARCHER_DETECTION = "搜尋者偵測"
    TX_SUBMISSION = "交易提交"
    BLOCK_BUILDING = "區塊構建"
    BLOCK_PROPOSAL = "區塊提議"
    LIQUIDATION_COMPLETE = "清算完成"

@dataclass
class SimulationEvent:
    timestamp: float
    event_type: LiquidationEventType
    description: str
    data: dict

@dataclass
class LiquidationSimulationState:
    eth_price: float
    health_factor: float
    searcher_bids: List[dict]
    liquidation_tx_submitted: bool
    liquidation_in_block: bool
    liquidation_complete: bool

def simulate_liquidation_timing(
    initial_eth_price: float = 3300.0,
    liquidation_trigger_price: float = 2800.0,
    debt_usdc: float = 2800.0,
    liquidation_bonus: float = 0.08,
    gas_cost_usd: float = 50.0,
    num_searchers: int = 5,
    avg_network_latency_ms: float = 100.0,
    block_time_seconds: float = 12.0,
    random_seed: int = 42
) -> dict:
    """
    模擬清算觸發的完整時序過程
    """
    np.random.seed(random_seed)
    
    events = []
    state = LiquidationSimulationState(
        eth_price=initial_eth_price,
        health_factor=1.0,
        searcher_bids=[],
        liquidation_tx_submitted=False,
        liquidation_in_block=False,
        liquidation_complete=False
    )
    
    current_time = 0.0
    
    # 事件 1：價格下跌
    price_drop = initial_eth_price - liquidation_trigger_price - 1
    state.eth_price = initial_eth_price - price_drop
    
    # 健康因子重新計算
    collateral = debt_usdc / liquidation_trigger_price  # 清算時的抵押品
    state.health_factor = (collateral * state.eth_price * 0.825) / debt_usdc
    
    events.append(SimulationEvent(
        timestamp=current_time,
        event_type=LiquidationEventType.HEALTH_FACTOR_UPDATE,
        description=f"ETH 價格下跌至 ${state.eth_price:.2f}",
        data={
            "new_price": state.eth_price,
            "price_drop_pct": (price_drop / initial_eth_price) * 100,
            "health_factor": state.health_factor,
            "liquidation_triggered": state.health_factor < 1.0
        }
    ))
    
    current_time += 0.001  # 1ms
    
    # 事件 2：搜尋者偵測（並發）
    for i in range(num_searchers):
        # 每個搜尋者有不同的偵測延遲
        detection_delay = np.random.exponential(avg_network_latency_ms / 1000)
        
        # 利潤計算
        collateral_value = collateral * state.eth_price
        bonus_value = collateral_value * liquidation_bonus
        profit = bonus_value - gas_cost_usd
        
        # 搜尋者競標（支付意願 = 利潤的某個百分比）
        bid_pct = np.random.uniform(0.5, 0.95)
        bid = {
            "searcher_id": i,
            "detection_time": current_time + detection_delay,
            "profit": profit,
            "bid": profit * bid_pct,
            "willing_to_pay": profit * bid_pct
        }
        state.searcher_bids.append(bid)
    
    events.append(SimulationEvent(
        timestamp=current_time,
        event_type=LiquidationEventType.SEARCHER_DETECTION,
        description=f"{num_searchers} 個搜尋者偵測到清算機會",
        data={
            "num_searchers": num_searchers,
            "average_profit": np.mean([s["profit"] for s in state.searcher_bids]),
            "max_profit": max(s["profit"] for s in state.searcher_bids),
            "winning_searcher": max(state.searcher_bids, key=lambda x: x["profit"])["searcher_id"]
        }
    ))
    
    current_time += 0.5  # 500ms
    
    # 事件 3：最優搜尋者提交交易
    winning_searcher = max(state.searcher_bids, key=lambda x: x["profit"])
    
    events.append(SimulationEvent(
        timestamp=current_time,
        event_type=LiquidationEventType.TX_SUBMISSION,
        description=f"搜尋者 #{winning_searcher['searcher_id']} 提交清算交易",
        data={
            "searcher_id": winning_searcher["searcher_id"],
            "profit": winning_searcher["profit"],
            "bid": winning_searcher["bid"],
            "gas_cost_usd": gas_cost_usd,
            "net_profit": winning_searcher["profit"] - gas_cost_usd
        }
    ))
    
    state.liquidation_tx_submitted = True
    current_time += 1.0  # 1s
    
    # 事件 4：區塊構建（等待下一區塊）
    next_block_time = block_time_seconds - (current_time % block_time_seconds)
    current_time += next_block_time
    
    events.append(SimulationEvent(
        timestamp=current_time,
        event_type=LiquidationEventType.BLOCK_BUILDING,
        description="區塊構建者將清算交易包含進區塊",
        data={
            "block_included": True,
            "gas_used": 500000,  # 典型清算交易
            "gas_price_gwei": 30,
            "total_gas_cost": 0.015,  # ETH
            "searcher_net_profit_after_mev_cut": winning_searcher["profit"] * 0.65
        }
    ))
    
    state.liquidation_in_block = True
    current_time += 0.5  # 500ms for proposal
    
    # 事件 5：區塊提議
    events.append(SimulationEvent(
        timestamp=current_time,
        event_type=LiquidationEventType.BLOCK_PROPOSAL,
        description="驗證者提議並確認區塊",
        data={
            "slots_to_finality": 2,  # 通常 2 個 slots
            "finalization_time": block_time_seconds * 2
        }
    ))
    
    current_time += block_time_seconds * 2
    
    # 事件 6：清算完成
    events.append(SimulationEvent(
        timestamp=current_time,
        event_type=LiquidationEventType.LIQUIDATION_COMPLETE,
        description="清算最終確認完成",
        data={
            "collateral_liquidated": collateral,
            "debt_covered": debt_usdc,
            "bonus_received": collateral * liquidation_bonus,
            "searcher_final_profit": winning_searcher["profit"] * 0.65 - gas_cost_usd,
            "total_time_seconds": current_time,
            "from_trigger_to_complete": current_time
        }
    ))
    
    state.liquidation_complete = True
    
    return {
        "events": events,
        "final_state": state,
        "total_time_seconds": current_time,
        "winner": winning_searcher
    }

# 執行模擬
simulation = simulate_liquidation_timing()

print("=== 清算觸發時序模擬結果 ===\n")
for event in simulation["events"]:
    print(f"[T+{event.timestamp:.3f}s] {event.event_type.value}")
    print(f"  {event.description}")
    for key, value in event.data.items():
        print(f"    - {key}: {value}")
    print()

9.2.3 多帳戶清算競爭模擬

def simulate_multi_account_liquidation_race(
    accounts: List[dict],
    searchers: List[dict],
    block_time: float = 12.0
) -> pd.DataFrame:
    """
    模擬多個帳戶同時達到清算條件時的競爭情況
    """
    results = []
    
    # 每個帳戶的清算截止時間計算
    for account in accounts:
        # 計算距離清算的剩餘空間
        price_to_liquidation = account["current_price"] - account["liquidation_price"]
        price_buffer_pct = price_to_liquidation / account["current_price"]
        
        # 估算觸發時間（假設線性下跌）
        time_to_liquidation = price_buffer_pct / account["volatility_per_hour"] * 3600
        
        results.append({
            "account": account["name"],
            "current_price": account["current_price"],
            "liquidation_price": account["liquidation_price"],
            "debt_usdc": account["debt"],
            "health_factor": account["health_factor"],
            "time_to_liquidation_hours": time_to_liquidation,
            "potential_profit": account["debt"] * 0.08,  # 8% 獎勵
            "triggered": account["health_factor"] < 1.0
        })
    
    df = pd.DataFrame(results)
    
    # 計算市場影響（多帳戶同時清算）
    triggered_df = df[df["triggered"]]
    total_debt = triggered_df["debt_usdc"].sum()
    total_collateral = triggered_df["debt_usdc"].sum() / df["liquidation_price"].mean()
    
    # 市場影響估算
    market_impact = total_collateral * df["liquidation_price"].mean() * 0.01  # 1% 滑點
    
    print("\n=== 多帳戶清算市場影響分析 ===")
    print(f"\n待清算帳戶數: {len(triggered_df)}")
    print(f"總債務: ${total_debt:,.2f}")
    print(f"估計市場影響: ${market_impact:,.2f}")
    
    return df

# 執行多帳戶模擬
accounts = [
    {"name": "鯨魚A", "current_price": 3100, "liquidation_price": 2800, "debt": 100000, "health_factor": 0.95, "volatility_per_hour": 0.02},
    {"name": "機構B", "current_price": 3200, "liquidation_price": 2850, "debt": 250000, "health_factor": 0.98, "volatility_per_hour": 0.015},
    {"name": "散戶C", "current_price": 3150, "liquidation_price": 2900, "debt": 15000, "health_factor": 0.99, "volatility_per_hour": 0.025},
    {"name": "交易員D", "current_price": 3250, "liquidation_price": 2950, "debt": 80000, "health_factor": 1.02, "volatility_per_hour": 0.018},
]

results_df = simulate_multi_account_liquidation_race(accounts, [])
print(results_df.to_string(index=False))

9.3 清算風險監控儀表板

9.3.1 即時風險計算器

class LiquidationRiskMonitor:
    """
    即時清算風險監控器
    """
    
    def __init__(self, rpc_url: str):
        self.web3 = Web3(Web3.HTTPProvider(rpc_url))
        
        # 主流借貸協議地址（Aave V3, Compound V3, MakerDAO）
        self.protocols = {
            "aave_v3": {
                "address": "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",
                "pool": "0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2",
                "health_factor_func": self._get_aave_health_factor
            },
            "compound_v3": {
                "address": "0xc3d688B66703497DAA19211EEdff47f25384cdc3",
                "health_factor_func": self._get_compound_health_factor
            }
        }
    
    def get_portfolio_risk(self, wallet_address: str) -> dict:
        """
        獲取錢包地址在所有協議中的清算風險
        """
        risks = {}
        total_exposure = 0.0
        max_risk = 0.0
        
        for protocol_name, protocol in self.protocols.items():
            risk = protocol["health_factor_func"](wallet_address)
            if risk:
                risks[protocol_name] = risk
                total_exposure += risk.get("total_debt_usd", 0)
                max_risk = max(max_risk, 1 - risk.get("health_factor", 999))
        
        return {
            "wallet": wallet_address,
            "protocols": risks,
            "total_debt_usd": total_exposure,
            "overall_health_factor": min(
                [r.get("health_factor", 999) for r in risks.values()]
            ) if risks else 999,
            "liquidation_risk_score": max_risk * 100,  # 0-100%
            "risk_level": self._classify_risk(max_risk),
            "recommendations": self._generate_recommendations(risks)
        }
    
    def _classify_risk(self, risk_score: float) -> str:
        if risk_score <= 0.1:
            return "🟢 安全"
        elif risk_score <= 0.3:
            return "🟡 適中"
        elif risk_score <= 0.5:
            return "🟠 警告"
        else:
            return "🔴 危險"
    
    def _generate_recommendations(self, risks: dict) -> List[str]:
        recommendations = []
        
        for protocol, risk in risks.items():
            hf = risk.get("health_factor", 999)
            
            if hf < 1.2:
                recommendations.append(
                    f"⚠️ {protocol}: 健康因子 {hf:.2f}，建議立即增加抵押品"
                )
            elif hf < 1.5:
                recommendations.append(
                    f"💡 {protocol}: 健康因子 {hf:.2f}，可考慮增加抵押品降低風險"
                )
        
        if not recommendations:
            recommendations.append("✅ 所有頭寸健康狀況良好")
        
        return recommendations
    
    def _get_aave_health_factor(self, wallet: str) -> Optional[dict]:
        # Aave V3 實際調用邏輯
        # 簡化版本
        return None  # 需要實際 RPC 連接
    
    def _get_compound_health_factor(self, wallet: str) -> Optional[dict]:
        # Compound V3 實際調用邏輯
        return None

第十章：2026 年第一季度 DeFi 市場數據更新

10.1 主要借貸協議最新數據

截至 2026 年 3 月 21 日的市場數據：

10.2 ETH 質押與借貸關係

10.3 Gas 費用對清算的影響

結論

本文提供了 DeFi 清算風險的完整量化計算框架，涵蓋：

1. 理論基礎：健康因子、擔保率、清算閾值的數學推導
2. 協議實作：Aave V3、Compound V3、MakerDAO 的清算機制比較
3. 風險量化：波動率分析、蒙特卡羅模擬、壓力測試
4. MEV 獎勵分配：清算利潤在各角色之間的分配機制
5. 時序模擬：清算觸發的完整時間線和競爭情況
6. 最新市場數據：2026 年第一季度的 DeFi 市場狀況

理解這些清算機制的數學原理和實際運作，對於 DeFi 開發者、風險管理者和投資者都至關重要。

本文為 DeFi 清算風險量化計算的技術指南，所有計算範例僅供教育和學習目的。實際 DeFi 操作涉及智能合約風險，投資者應在充分了解風險後謹慎決策。