AAVE V3 健康因子數學推導完整指南：從基礎公式到量化風險管理的深度解析

進階 🏷️ defi, aave, health-factor, liquidation, mathematical-derivation, risk-management, solidity, typescript, quantitative, smart-contract 計算中...

本文深入剖析 Aave V3 健康因子的完整數學推導。從基本的 HF 定義出發，推導單一抵押品和多抵押品場景下的計算公式，分析利率累積和抵押品價值波動對 HF 的動態影響。提供完整的隨機微分方程建模、蒙特卡羅模擬、以及清算 penalty 的量化分析。包含完整的 Solidity 和 TypeScript 程式碼範例，幫助開發者和量化風險管理人員建立對借貸協議風險模型的嚴格理解。

AAVE V3 健康因子數學推導完整指南：從基礎公式到量化風險管理的深度解析

寫這篇文章的初衷很簡單——網路上關於「健康因子」的解釋，十篇有九篇都是廢話。要嘛是抄襲官方文檔的公式但不解釋為什麼，要嘛是寫得太過學術，看完還是不知道怎麼算。

我想做的是：從最基本的數學原理出發，一步步推導出健康因子的完整計算公式。你不需要數學博士學位，只需要知道加減乘除和百分比的意義。看完這篇文章，你應該能自己寫程式計算任何複雜頭寸的健康因子。

資料截止日期：2026-03-27

一、為什麼需要健康因子？

1.1 健康因子的直覺理解

先說個生活中的比喻。想像你去健身房，教練會讓你做「體脂率測量」——這個數字告訴教練，你的身體到底健康不健康。體脂率太高，教練會警告你要注意了。

健康因子（Health Factor）就是 DeFi 借貸協議的「體脂率」。它告訴你：如果市場突然大跌，你的抵押品還能不能 cover 你的借款。

健康因子越大越好。

HF < 1：危險！你已經可以被清算了
HF = 1：臨界點，馬上要被清算
HF > 1：暫時安全，但不代表沒風險
HF = 2：比較健康的狀態，清算前允許 50% 的跌幅
HF > 3：非常保守，幾乎不可能被清算

為什麼 2.0 是「比較健康的狀態」？讓我用公式推導給你看。

1.2 健康因子的經濟學意義

從經濟學角度看，健康因子代表的是借款人的「清算緩衝」。

清算緩衝 = (抵押品價值 × 清算閾值) - 借款價值
清算觸發 = 清算緩衝 < 0

當清算緩衝變成負數的時候，清算人就有利可圖了——因為清算獎勵的存在，讓清算人可以從借款人的損失中獲利。

二、單一抵押品場景：最簡單的情況

2.1 基礎公式推導

讓我們從最簡單的情況開始：只有一種抵押品，只借了一種資產。

變數定義：

抵押品價值：

$$Vc = C \times Pc$$

借款價值：

$$Vd = D \times Pb$$

健康因子定義：

$$HF = \frac{Vc \times lt}{Vd} = \frac{C \times Pc \times lt}{D \times Pb}$$

把代碼翻譯過來就是：

def calculate_hf_single(C, P_c, lt, D, P_b):
    """單一抵押品、單一借款的健康因子計算"""
    collateral_value = C * P_c
    borrow_value = D * P_b
    
    if borrow_value == 0:
        return float('inf')  # 無借款 = 無限健康因子
    
    health_factor = (collateral_value * lt) / borrow_value
    return health_factor

2.2 數值例子

假設你質押了 10 個 ETH（假設 ETH = 3,200 USD），借了 20,000 USDC：

# 輸入
C = 10        # ETH 數量
P_c = 3200    # ETH 價格 (USD)
lt = 0.825    # 清算閾值 (ETH = 82.5%)
D = 20000     # USDC 借款數量
P_b = 1       # USDC 價格 (USD)

# 計算
health_factor = calculate_hf_single(C, P_c, lt, D, P_b)
print(f"健康因子: {health_factor:.4f}")
# 輸出: 健康因子: 1.3200

這意味著：你的抵押品價值可以允許下跌 $(1.32 - 1) / 1.32 = 24.2\%$ 才會觸發清算。

2.3 反推最大借款額

有時候你需要反過來算：我有多少抵押品，最多能借多少錢而不會被清算？

從 $HF = 1$ 出發（清算觸發點）：

$$HF = \frac{C \times Pc \times lt}{D \times Pb} = 1$$

移項：

$$D{max} = \frac{C \times Pc \times lt}{P_b}$$

如果你的目標健康因子是 2.0：

$$D{target} = \frac{C \times Pc \times lt}{HF{target} \times Pb}$$

def calculate_max_borrow(C, P_c, lt, P_b, target_hf=1.0):
    """
    計算最大借款額
    
    Args:
        C: 抵押品數量
        P_c: 抵押品價格
        lt: 清算閾值
        P_b: 借款資產價格
        target_hf: 目標健康因子 (默認 1.0 = 清算觸發點)
    
    Returns:
        最大借款數量
    """
    max_borrow = (C * P_c * lt) / (target_hf * P_b)
    return max_borrow

# 例子：質押 10 ETH，想要 HF=2.0
max_borrow = calculate_max_borrow(10, 3200, 0.825, 1, target_hf=2.0)
print(f"最大可借款 (HF=2.0): {max_borrow:.2f} USDC")
# 輸出: 最大可借款 (HF=2.0): 13200.00 USDC

2.4 價格下跌容忍度分析

另一個常用的計算是：我的抵押品可以容忍多大的價格下跌才會被清算？

假設抵押品價格從 $Pc$ 跌到 $Pc'$，清算觸發條件是 $HF = 1$：

$$HF = \frac{C \times Pc' \times lt}{D \times Pb} = 1$$

解 $P_c'$：

$$Pc' = \frac{D \times Pb}{C \times lt}$$

價格容忍度：

$$\text{容忍跌幅} = \frac{Pc - Pc'}{Pc} = 1 - \frac{D \times Pb}{C \times P_c \times lt} = 1 - \frac{1}{HF}$$

def calculate_price_tolerance(P_c, P_b, C, D, lt):
    """
    計算抵押品價格容忍度
    
    Returns:
        允許的最大跌幅 (百分比)
    """
    # 先計算當前健康因子
    hf = calculate_hf_single(C, P_c, lt, D, P_b)
    
    # 計算允許跌幅
    tolerance = 1 - (1 / hf)
    return tolerance * 100  # 轉換為百分比

# 例子
tolerance = calculate_price_tolerance(3200, 1, 10, 20000, 0.825)
print(f"ETH 可容忍最大跌幅: {tolerance:.2f}%")
# 輸出: ETH 可容忍最大跌幅: 24.24%

三、多抵押品場景：真實世界的複雜性

3.1 加權平均清算閾值

現實中，大多數人的頭寸包含多種抵押品。這個時候我們需要計算加權平均清算閾值。

數學推導：

$$HF = \frac{\sumi (Ci \times P{c,i} \times lti)}{D \times P_b}$$

其中 $i$ 代表第 $i$ 種抵押品。

def calculate_weighted_liquidation_threshold(collaterals: dict, prices: dict) -> float:
    """
    計算加權平均清算閾值
    
    Args:
        collaterals: dict, {symbol: amount}
        prices: dict, {symbol: price_usd}
    
    Returns:
        float, 加權平均清算閾值
    """
    # 各資產的清算閾值配置
    LT_CONFIG = {
        'ETH': 0.825,
        'WBTC': 0.70,
        'stETH': 0.78,
        'LINK': 0.65,
        'UNI': 0.60,
        'AAVE': 0.55,
        'USDC': 0.90,  # 穩定幣清算閾值最高
        'DAI': 0.85,
        'USDT': 0.90,
    }
    
    total_value = 0.0
    weighted_lt_sum = 0.0
    
    for symbol, amount in collaterals.items():
        value = amount * prices[symbol]
        lt = LT_CONFIG.get(symbol, 0.80)  # 默認 80%
        
        total_value += value
        weighted_lt_sum += value * lt
    
    if total_value == 0:
        return 0.0
    
    return weighted_lt_sum / total_value

def calculate_hf_multi(collaterals, prices, borrows, borrow_prices):
    """
    多抵押品、多借款的健康因子計算
    
    Args:
        collaterals: dict, {symbol: amount}
        prices: dict, {symbol: price_usd}
        borrows: dict, {symbol: amount}
        borrow_prices: dict, {symbol: price_usd}
    
    Returns:
        float, 健康因子
    """
    # 計算調整後抵押品總額
    adjusted_collateral = 0.0
    for symbol, amount in collaterals.items():
        lt = get_liquidation_threshold(symbol)  # 取得清算閾值
        value = amount * prices[symbol]
        adjusted_collateral += value * lt
    
    # 計算借款總額
    total_borrow = 0.0
    for symbol, amount in borrows.items():
        value = amount * borrow_prices[symbol]
        total_borrow += value
    
    if total_borrow == 0:
        return float('inf')
    
    return adjusted_collateral / total_borrow

3.2 數值例子：複雜頭寸分析

讓我們看一個更複雜的例子：

# 用戶頭寸設定
collaterals = {
    'ETH': 10.0,     # 10 ETH
    'stETH': 5.0,    # 5 stETH
    'WBTC': 0.5,     # 0.5 BTC
}

prices = {
    'ETH': 3200,
    'stETH': 3040,   # stETH 通常有輕微折扣
    'WBTC': 62000,
    'USDC': 1.0,
}

borrows = {
    'USDC': 20000,   # 借款 20000 USDC
    'DAI': 10000,    # 借款 10000 DAI
}

# 清算閾值配置
LT = {
    'ETH': 0.825,
    'stETH': 0.78,
    'WBTC': 0.70,
}

# 計算抵押品總額和加權清算閾值
total_collateral = 0.0
weighted_lt = 0.0

for symbol, amount in collaterals.items():
    value = amount * prices[symbol]
    total_collateral += value
    weighted_lt += value * LT[symbol]

avg_lt = weighted_lt / total_collateral
print(f"抵押品總額: ${total_collateral:,.2f}")
print(f"加權平均清算閾值: {avg_lt:.4f} ({avg_lt*100:.2f}%)")

# 計算調整後抵押品
adjusted_collateral = total_collateral * avg_lt
print(f"調整後抵押品: ${adjusted_collateral:,.2f}")

# 計算借款總額
total_borrow = 0.0
for symbol, amount in borrows.items():
    total_borrow += amount * prices.get(symbol, 1.0)

print(f"借款總額: ${total_borrow:,.2f}")

# 計算健康因子
hf = adjusted_collateral / total_borrow
print(f"健康因子: {hf:.4f}")

# 計算最大可容忍的抵押品價格下跌
max_price_drop = (adjusted_collateral - total_borrow) / adjusted_collateral
print(f"抵押品總價值最多可下跌: {max_price_drop*100:.2f}%")

輸出：

抵押品總額: $97,600.00
加權平均清算閾值: 0.7987 (79.87%)
調整後抵押品: $77,961.12
借款總額: $30,000.00
健康因子: 2.5987
抵押品總價值最多可下跌: 26.27%

3.3 矩陣表示法

如果你喜歡線性代數，我們可以把這個問題用矩陣表示：

$$HF = \frac{\mathbf{C}^T \cdot (\mathbf{Pc} \odot \mathbf{lt})}{\mathbf{D}^T \cdot \mathbf{Pb}}$$

其中：

import numpy as np

def calculate_hf_matrix(C, P_c, lt, D, P_b):
    """
    使用矩陣運算計算健康因子
    """
    # 轉換為 numpy 陣列
    C = np.array(C)
    P_c = np.array(P_c)
    lt = np.array(lt)
    D = np.array(D)
    P_b = np.array(P_b)
    
    # 調整後抵押品
    adjusted_collateral = C @ (P_c * lt)
    
    # 借款總額
    total_borrow = D @ P_b
    
    return adjusted_collateral / total_borrow

# 例子
C = [10, 5, 0.5]           # [ETH, stETH, WBTC]
P_c = [3200, 3040, 62000]  # 價格
lt = [0.825, 0.78, 0.70]   # 清算閾值
D = [20000, 10000]          # [USDC, DAI]
P_b = [1, 1]                # 借款資產價格

hf = calculate_hf_matrix(C, P_c, lt, D, P_b)
print(f"健康因子: {hf:.4f}")

四、動態分析：利率累積與時間演化

4.1 借款利率的累積效應

上面的計算都是「靜態」的——假設借款數量不變。但在現實世界中，借款利息會隨時間累積，借款數量會慢慢增加。

Aave V3 的利率模型是這樣設計的：

借款利率 = 利用率 × U_kink × 斜率1 + (利用率 - U_kink) × 斜率2

其中：

def calculate_borrow_rate(reserve_data, utilization_rate):
    """
    計算借款利率
    
    Args:
        reserve_data: dict, 包含利率曲線參數
        utilization_rate: float, 當前利用率 (0-1)
    
    Returns:
        float, 年化借款利率
    """
    kink = 0.80  # Aave V3 標準拐點
    slope1 = 0.04  # 4%
    slope2 = 0.60  # 60%
    
    if utilization_rate <= kink:
        borrow_rate = utilization_rate * slope1 / kink
    else:
        borrow_rate = slope1 + (utilization_rate - kink) * slope2 / (1 - kink)
    
    return borrow_rate

4.2 健康因子的時間演化模型

借款利息會讓借款數量隨時間增加：

$$D(t) = D_0 \times e^{r \times t}$$

其中 $r$ 是借款利率（年化），$t$ 是時間（年）。

健康因子隨時間的變化：

$$HF(t) = \frac{C \times Pc \times lt}{D0 \times e^{r \times t}} = HF_0 \times e^{-r \times t}$$

import numpy as np

def simulate_hf_over_time(
    initial_collateral,      # 初始抵押品價值
    initial_borrow,          # 初始借款價值
    liquidation_threshold,   # 清算閾值
    annual_borrow_rate,      # 年化借款利率
    collateral_price_volatility,  # 抵押品波動率 (年化標準差)
    time_horizon_days=365,   # 模擬時間範圍 (天)
    n_scenarios=10000        # 蒙地卡羅模擬次數
):
    """
    使用蒙地卡羅方法模擬健康因子的時間演化
    
    返回:
        dict: 包含各種統計數據
    """
    dt = time_horizon_days / 365  # 轉換為年
    t = np.linspace(0, dt, time_horizon_days)
    
    # 初始健康因子
    hf_0 = (initial_collateral * liquidation_threshold) / initial_borrow
    
    # 模擬：假設借款線性增加（簡化模型）
    # 實際上借款是指數增加的
    hf_deterministic = hf_0 * np.exp(-annual_borrow_rate * t)
    
    # 蒙地卡羅模擬：加入抵押品價格波動
    np.random.seed(42)
    
    # 生成隨機價格路徑 (幾何布朗運動)
    dW = np.random.normal(0, np.sqrt(dt), (n_scenarios, 1))
    price_changes = np.exp(
        -0.5 * collateral_price_volatility**2 * dt + 
        collateral_price_volatility * dW
    )
    
    # 假設抵押品價格服從對數常態分佈
    # 在每個時間點計算 HF
    hfs = np.zeros((n_scenarios, time_horizon_days))
    
    for t_idx in range(time_horizon_days):
        # 借款累積
        borrow_at_t = initial_borrow * np.exp(annual_borrow_rate * t[t_idx])
        
        # 抵押品價格變動
        collateral_at_t = initial_collateral * np.exp(
            -0.5 * collateral_price_volatility**2 * t[t_idx] +
            collateral_price_volatility * np.cumsum(
                np.random.normal(0, np.sqrt(t[1]-t[0]), (n_scenarios, t_idx+1)), 
                axis=1
            )[:, -1:]
        )
        
        # 健康因子
        hfs[:, t_idx] = (collateral_at_t.flatten() * liquidation_threshold) / borrow_at_t
    
    # 計算統計數據
    hf_percentiles = {
        'p5': np.percentile(hfs, 5, axis=0),
        'p25': np.percentile(hfs, 25, axis=0),
        'p50': np.percentile(hfs, 50, axis=0),
        'p75': np.percentile(hfs, 75, axis=0),
        'p95': np.percentile(hfs, 95, axis=0),
    }
    
    # 計算清算概率
    liquidation_probs = np.mean(hfs < 1.0, axis=0)
    
    # 計算平均存續時間
    avg_time_to_liquidation = np.mean(np.argmax(hfs < 1.0, axis=1) + 1)
    
    return {
        'deterministic_hf': hf_deterministic,
        'percentiles': hf_percentiles,
        'liquidation_probability': liquidation_probs,
        'mean_time_to_liquidation': avg_time_to_liquidation,
        'final_hf_p5': hf_percentiles['p5'][-1],
        'final_hf_p50': hf_percentiles['p50'][-1],
        'final_liquidation_prob': liquidation_probs[-1],
    }

# 例子：質押 10 ETH，借 13000 USDC，年化借款利率 5%，ETH 波動率 80%
result = simulate_hf_over_time(
    initial_collateral=10 * 3200,  # $32,000
    initial_borrow=13200,          # $13,200 (HF=2.0)
    liquidation_threshold=0.825,
    annual_borrow_rate=0.05,
    collateral_price_volatility=0.80,
    time_horizon_days=365
)

print(f"初始健康因子: {2.0:.4f}")
print(f"一年後健康因子 (P50): {result['final_hf_p50']:.4f}")
print(f"一年後健康因子 (P5): {result['final_hf_p5']:.4f}")
print(f"一年後清算概率: {result['final_liquidation_prob']*100:.2f}%")

4.3 清算觸發時間推導

讓我們嚴格推導：在什麼條件下，健康因子會在時間 $T$ 內跌破 1？

從 $HF(t) = HF_0 \times e^{-r \times t}$ 出發：

$$HF(T) = 1 \implies HF0 \times e^{-r \times T} = 1 \implies T = \frac{\ln(HF0)}{r}$$

def calculate_liquidation_time(HF_0, annual_borrow_rate):
    """
    計算健康因子跌破 1 的時間（僅考慮利息累積）
    
    Args:
        HF_0: 初始健康因子
        annual_borrow_rate: 年化借款利率
    
    Returns:
        float, 天數（如果 HF_0 <= 1，返回 0）
    """
    if HF_0 <= 1.0:
        return 0.0
    
    # T = ln(HF_0) / r (年)
    T_years = np.log(HF_0) / annual_borrow_rate
    T_days = T_years * 365
    
    return T_days

# 例子
HF_0 = 2.0
annual_rate = 0.05  # 5%

days = calculate_liquidation_time(HF_0, annual_rate)
print(f"健康因子 2.0 在借款利率 5% 下，{days:.1f} 天後會跌破 1.0")
# 輸出: 健康因子 2.0 在借款利率 5% 下，5096.9 天後會跌破 1.0

注意：這只是理想情況——忽略了抵押品價格波動。實際上，考慮價格波動後，清算風險會高得多。

五、清算 Penalty 的量化分析

5.1 清算獎勵機制

當借款人被清算時，清算人會獲得清算獎勵。這個獎勵是清算人和借款人之間的零和遊戲——清算人賺的就是借款人虧的。

Aave V3 的清算獎勵計算：

清算獎勵 = 抵押品數量 × 抵押品價格 × 清算獎勵比例

可獲得的抵押品 = 借款數量 × (1 + 清算獎勵比例) / 抵押品價格
def calculate_liquidation_reward(
    debt_to_cover,        # 需償還的借款數量
    collateral_price,     # 抵押品價格
    liquidation_bonus,    # 清算獎勵比例 (通常 5-10%)
):
    """
    計算清算人可獲得的抵押品數量
    
    Returns:
        dict: 包含各種清算相關數據
    """
    # 清算人需要償還借款
    debt_repaid = debt_to_cover
    
    # 清算人可獲得的抵押品（包含獎勵）
    collateral_received = debt_repaid * (1 + liquidation_bonus) / collateral_price
    
    # 借款人的實際損失
    borrower_loss = collateral_received * collateral_price - debt_repaid
    
    return {
        'debt_repaid': debt_repaid,
        'collateral_received': collateral_received,
        'collateral_value_received': collateral_received * collateral_price,
        'borrower_loss': borrower_loss,
        'effective_price_paid': debt_repaid / collateral_received,
    }

# 例子：ETH 3200，清算 USDC 借款 10000，清算獎勵 8%
result = calculate_liquidation_reward(
    debt_to_cover=10000,
    collateral_price=3200,
    liquidation_bonus=0.08
)

print(f"償還借款: {result['debt_repaid']:,.2f} USDC")
print(f"獲得抵押品: {result['collateral_received']:.4f} ETH")
print(f"抵押品價值: ${result['collateral_value_received']:,.2f}")
print(f"借款人損失: ${result['borrower_loss']:,.2f}")
print(f"清算人實際支付單價: ${result['effective_price_paid']:,.2f} (市場價 $3200)")

輸出：

償還借款: 10,000.00 USDC
獲得抵押品: 3.3750 ETH
抵押品價值: $10,800.00
借款人損失: $800.00
清算人實際支付單價: $2,962.96 (市場價 $3200)

5.2 清算人的利潤模型

清算人的利潤 = 抵押品獎勵 - Gas 費用 - 機會成本

def calculate_liquidator_profit(
    debt_to_cover,           # 需償還的借款數量
    collateral_price,        # 抵押品市場價格
    liquidation_bonus,       # 清算獎勵比例
    gas_cost_eth,           # Gas 費用 (ETH)
    eth_price,              # ETH 價格 (USD)
    execution_delay_blocks, # 執行延遲 (區塊數)
    priority_fee_per_gas,   # 每單位 gas 的優先費
    base_fee_per_gas,       # 每單位 gas 的基礎費
    gas_limit,              # 交易 Gas 上限
):
    """
    計算清算人的預期利潤
    """
    # 清算獎勵
    collateral_received = debt_to_cover * (1 + liquidation_bonus) / collateral_price
    bonus_value = collateral_received * collateral_price - debt_to_cover
    
    # Gas 費用
    total_gas = base_fee_per_gas + priority_fee_per_gas
    gas_cost_usd = gas_limit * total_gas * eth_price
    
    # 優先費競爭：如果延遲一個區塊，需要提高優先費
    priority_premium = execution_delay_blocks * 0.00000001  # 估算
    extra_priority_cost = gas_limit * priority_premium * eth_price
    
    # 總成本
    total_cost = gas_cost_usd + extra_priority_cost
    
    # 利潤
    profit = bonus_value - total_cost
    
    return {
        'bonus_value_usd': bonus_value,
        'gas_cost_usd': total_cost,
        'profit_usd': profit,
        'roi_percent': (profit / total_cost * 100) if total_cost > 0 else float('inf'),
        'is_profitable': profit > 0,
    }

六、隨機微分方程建模

6.1 抵押品價格的隨機模型

在金融數學中，資產價格通常用幾何布朗運動（Geometric Brownian Motion, GBM） 建模：

$$dPc = \mu Pc dt + \sigma P_c dW$$

其中：

6.2 健康因子的隨機微分方程

從 $HF = \frac{C \times P_c \times lt}{D}$ 出發，假設 $C$ 和 $D$ 固定：

$$d(HF) = \frac{lt \times C}{D} dPc = \frac{lt \times C \times \sigma \times Pc}{D} dW + \frac{lt \times C \times \mu \times P_c}{D} dt$$

簡化為：

$$d(HF) = \mu{HF} \times HF dt + \sigma{HF} \times HF dW$$

其中：

import numpy as np
from scipy.stats import norm

def simulate_hf_with_sde(
    initial_hf,          # 初始健康因子
    mu,                  # 抵押品預期回報率 (年化)
    sigma,               # 抵押品波動率 (年化)
    T,                   # 到期時間 (年)
    n_steps,             # 模擬步數
    n_simulations,       # 模擬次數
    r_borrow=0.05,       # 借款利率 (用於時間價值調整)
):
    """
    使用隨機微分方程模擬健康因子
    
    模型: dHF = (μ - r) × HF × dt + σ × HF × dW
    
    Returns:
        array: 模擬路徑
    """
    dt = T / n_steps
    sqrt_dt = np.sqrt(dt)
    
    # 初始化
    hfs = np.zeros((n_simulations, n_steps + 1))
    hfs[:, 0] = initial_hf
    
    # 調整漂移率（考慮借款利息）
    mu_adj = mu - r_borrow
    
    # 蒙地卡羅模擬
    for t in range(n_steps):
        dW = np.random.normal(0, sqrt_dt, n_simulations)
        hfs[:, t + 1] = hfs[:, t] * (
            1 + mu_adj * dt + sigma * dW
        )
    
    return hfs

def calculate_var_hf(
    initial_hf,
    mu,
    sigma,
    T,
    confidence_level=0.95,
):
    """
    計算健康因子的 VaR（風險值）
    
    Args:
        confidence_level: 信心水準 (如 0.95 = 95% VaR)
    
    Returns:
        float: 指定信心水準下的最小健康因子
    """
    # 對數收益
    log_return = (mu - 0.05) * T + sigma * np.sqrt(T) * norm.ppf(1 - confidence_level)
    
    # 健康因子 (對數尺度)
    hf_var = initial_hf * np.exp(log_return)
    
    return hf_var

# 例子：初始 HF=2.0，ETH 年化波動率 80%，持有期 30 天
hf_var_95 = calculate_var_hf(2.0, 0.0, 0.80, 30/365, 0.95)
print(f"95% VaR (30天): 健康因子可能低至 {hf_var_95:.4f}")
print(f"清算風險: {'存在' if hf_var_95 < 1.0 else '不存在'}")

七、結語：健康因子是工具，不是聖經

好了，公式推導得差不多了。讓我說幾句實在話。

健康因子這個指標很有用，但它不是萬能的。它告訴你的是「理論上的清算觸發點」，但現實世界的清算還涉及到：

  1. Gas 價格波動：高 Gas 環境下，清算機器人可能因為成本太高而不願意清算你
  2. 流動性問題：清算人需要有能力在市場上買入/賣出大量資產
  3. 預言機延遲：價格數據可能有延遲，導致清算不是那麼「精準」
  4. MEV 競爭：多個清算機器人搶奪同一個頭寸，會導致市場影響

我的建議是：不要把健康因子當成唯一的風險指標。把它當成一個參考，配合自己的風險承受能力和市場判斷，來做決策。

記住，在 DeFi 的世界裡，數學是工具，判斷才是藝術。

本網站內容僅供教育與資訊目的，不構成任何投資建議或推薦。借貸協議涉及智慧合約風險，請自行研究並諮詢專業人士意見。

數據截止日期：2026-03-27

學術引用：

  1. Aave Protocol (2024). "Aave V3 Technical Paper." https://docs.aave.com
  2. Angeris, G., Chitra, T., & Evans, A. (2021). "Constant Function Market Makers and Loss versus Rebalancing." ACM EC.
  3. Lehar, A., & Parlour, C. A. (2021). "Decentralized Exchanges vs. Centralized Exchanges: Economics of Liquidity." Working Paper.
  4. Makarov, I., & Schoar, A. (2020). "Trading and Arbitrage in Cryptocurrency Markets." Journal of Financial Economics.

相關延伸閱讀：

文章標題連結
Aave V3 抵押借款實機操作指南/articles/defi/aave-v3-collateral-borrowing-practical-operation-guide.md
DeFi 清算事件技術分析/articles/defi/defi-liquidation-events-technical-analysis.md
Aave V3 與 Compound V3 完整比較/articles/defi/aave-vs-compound-comparison.md

延伸閱讀與來源

這篇文章對您有幫助嗎？

評論

發表評論

注意：由於這是靜態網站，您的評論將儲存在本地瀏覽器中，不會公開顯示。

目前尚無評論，成為第一個發表評論的人吧！