DeFi 清算風險量化模型與蒙特卡羅模擬完整指南：從理論到實踐的工程實現
本文從工程師視角深入探討 DeFi 清算風險的量化模型、蒙特卡羅模擬方法論與實際程式碼實現。我們涵蓋健康因子計算、擔保不足風險分析、拍賣機制模擬、資產相關性風險評估，並提供完整的 Python 實現框架。通過歷史數據驗證與壓力測試案例，幫助開發者和投資者建立科學的風險評估體系。
DeFi 清算風險量化模型與蒙特卡羅模擬完整指南：從理論到實踐的工程實現
概述
去中心化金融（DeFi）借貸協議的清算機制是維持整個借貸生態系統健康運作的關鍵支柱。當借款人抵押品價值下跌至不足以覆蓋借款金額時，清算程序會自動啟動，將抵押品拍賣以償還債權人。這個機制的設計直接關係到借貸協議的穩健性與所有參與者的風險暴露程度。然而，在極端市場條件下，清算機制可能觸發連鎖反應，導致災難性的資產損失。
理解清算風險的量化模型對於開發者、協議營運者和投資者而言都至關重要。傳統的風險分析方法往往無法捕捉加密貨幣市場的特殊性質，包括極端的價格波動、24/7 交易的連續性以及市場流動性的快速變化。本文從工程師視角出發，深入探討 DeFi 清算風險的量化模型、蒙特卡羅模擬方法論、實際的程式碼實現，並通過歷史數據驗證模型的準確性，為讀者提供一套完整的風險評估工具箱。
第一章：清算風險的理論基礎
1.1 擔保不足與健康因子
DeFi 借貸協議的核心機制是超額抵押。用戶將加密貨幣資產作為抵押品存入協議，根據抵押品的價值和風險權重，可以借入一定比例的其他資產。這個可借款比例由擔保率（Collateral Factor）或Loan-to-Value（LTV）比率決定，反映了協議對抵押品價格波動的緩衝空間。
擔保率計算公式：
擔保率 = (抵押品價值 × 抵押品價格) / 借款價值
清算觸發條件：
當擔保率 < 清算閾值時，觸發清算程式
典型清算閾值：
- Aave V3：健康因子 < 1.0
- Compound V3：抵押因子 < 100%
- MakerDAO：清算比率 < 150%健康因子（Health Factor）是 Aave 等協議用於衡量借款人帳戶健康狀況的核心指標。其計算涉及抵押品價值、借款金額、以及各資產的清算閾值。當健康因子降至 1.0 以下時，任何人都可以執行清算操作。
# 健康因子計算實現
import numpy as np
from typing import List, Dict
class HealthFactorCalculator:
"""
DeFi 借貸協議健康因子計算器
支援 Aave V3 與 Compound V3 的計算邏輯
"""
def __init__(self, protocol: str = "aave_v3"):
self.protocol = protocol
self.liquidation_threshold = {
# Aave V3 典型清算閾值
"ETH": 0.80, # 80%
"WBTC": 0.75, # 75%
"USDC": 0.90, # 90%
"USDT": 0.90, # 90%
"DAI": 0.90, # 90%
"stETH": 0.75, # 75%
"LINK": 0.70, # 70%
}
def calculate_health_factor(
self,
collateral_assets: List[Dict],
borrow_assets: List[Dict]
) -> float:
"""
計算帳戶的健康因子
參數:
- collateral_assets: 抵押資產列表，每個元素包含 {'asset': str, 'amount': float, 'price': float}
- borrow_assets: 借款資產列表
返回:
- health_factor: 健康因子
"""
# 計算總抵押品價值（以美元計）
total_collateral_value = 0
weighted_collateral = 0
for asset in collateral_assets:
value = asset['amount'] * asset['price']
total_collateral_value += value
# 應用清算閾值作為權重
threshold = self.liquidation_threshold.get(asset['asset'], 0.70)
weighted_collateral += value * threshold
# 計算總借款價值
total_borrow_value = 0
for asset in borrow_assets:
value = asset['amount'] * asset['price']
total_borrow_value += value
# 計算健康因子
if total_borrow_value == 0:
return float('inf') # 無借款，健康因子無窮大
health_factor = weighted_collateral / total_borrow_value
return health_factor
def calculate_liquidation_threshold(
self,
collateral_assets: List[Dict],
borrow_assets: List[Dict]
) -> Dict[str, float]:
"""
計算清算觸發價格
當抵押品價格低於某個閾值時將觸發清算
"""
thresholds = {}
for i, asset in enumerate(collateral_assets):
if asset['amount'] == 0:
continue
# 計算該抵押品被清算時的總借款價值
other_collateral_value = sum(
a['amount'] * a['price']
for j, a in enumerate(collateral_assets)
if j != i
)
borrow_value = sum(
a['amount'] * a['price']
for a in borrow_assets
)
threshold = self.liquidation_threshold.get(asset['asset'], 0.70)
# 計算觸發清算的價格
if borrow_value > other_collateral_value * threshold:
required_value = borrow_value / threshold - other_collateral_value
trigger_price = required_value / asset['amount']
else:
trigger_price = 0
thresholds[asset['asset']] = max(0, trigger_price)
return thresholds
def is_liquidatable(
self,
collateral_assets: List[Dict],
borrow_assets: List[Dict]
) -> bool:
"""檢查帳戶是否可被清算"""
return self.calculate_health_factor(collateral_assets, borrow_assets) < 1.01.2 清算拍賣機制
當清算觸發後，抵押品需要被拍賣以償還債權人。不同的協議採用不同的拍賣機制，主要分為以下幾類：
荷蘭式拍賣（Dutch Auction）
荷蘭式拍賣是 Aave 等協議採用的方式。拍賣開始時，抵押品以高於市場價格的價格開拍，然後價格逐漸下降，直到有人願意購買。這種機制確保抵押品能夠快速出售，但可能導致借款人遭受更大的損失。
英國式拍賣（English Auction）
英國式拍賣從低價開始，競標者不斷抬高價格，最高出價者獲得拍賣品。這種機制通常能獲得更好的價格，但可能導致拍賣時間過長。
固定折扣清算
某些協議採用固定折扣的方式，直接以市場價格的一定折扣出售抵押品。這種方式簡單直接，但流動性供應商可能面臨選擇性風險。
// 荷蘭式拍賣清算邏輯
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
contract DutchAuctionLiquidation {
// 拍賣參數
uint256 public constant PRICE_DECREASE_RATE = 100; // 每秒降價幅度（basis points）
uint256 public constant AUCTION_DURATION = 3600; // 拍賣時長（1小時）
uint256 public constant MAX_DISCOUNT = 3000; // 最大折扣（30%）
struct Auction {
address borrower; // 借款人地址
address collateralToken; // 抵押資產
uint256 collateralAmount; // 抵押數量
uint256 debtToCover; // 覆蓋的債務
uint256 startTime; // 開始時間
uint256 startPrice; // 起始價格
uint256 currentPrice; // 當前價格
uint256 discountRate; // 折扣率
address liquidator; // 清算人
bool completed; // 是否完成
}
mapping(bytes32 => Auction) public auctions;
// 計算當前拍賣價格
function getCurrentPrice(bytes32 auctionId) public view returns (uint256) {
Auction storage auction = auctions[auctionId];
uint256 timeElapsed = block.timestamp - auction.startTime;
uint256 timeMultiplier = timeElapsed * PRICE_DECREASE_RATE;
// 計算累積折扣
uint256 totalDiscount = Math.min(
timeMultiplier,
MAX_DISCOUNT
);
// 計算當前價格
uint256 currentPrice = auction.startPrice * (10000 - totalDiscount) / 10000;
return currentPrice;
}
// 啟動清算拍賣
function startLiquidation(
address borrower,
address collateralToken,
uint256 collateralAmount,
uint256 debtToCover,
uint256 marketPrice
) internal returns (bytes32 auctionId) {
// 計算起始價格（高於市價 10%）
uint256 startPrice = marketPrice * 110 / 100;
auctionId = keccak256(abi.encodePacked(
borrower,
collateralToken,
block.timestamp
));
auctions[auctionId] = Auction({
borrower: borrower,
collateralToken: collateralToken,
collateralAmount: collateralAmount,
debtToCover: debtToCover,
startTime: block.timestamp,
startPrice: startPrice,
currentPrice: startPrice,
discountRate: PRICE_DECREASE_RATE,
liquidator: address(0),
completed: false
});
emit LiquidationStarted(
auctionId,
borrower,
collateralAmount,
debtToCover
);
}
// 執行清算
function executeLiquidation(
bytes32 auctionId,
uint256 debtAmount
) external returns (uint256 collateralReceived) {
Auction storage auction = auctions[auctionId];
require(!auction.completed, "Auction completed");
require(block.timestamp <= auction.startTime + AUCTION_DURATION, "Auction expired");
uint256 currentPrice = getCurrentPrice(auctionId);
// 計算可以獲得的抵押品數量
collateralReceived = debtAmount * 1e18 / currentPrice;
require(
collateralReceived <= auction.collateralAmount,
"Insufficient collateral"
);
// 更新拍賣狀態
auction.collateralAmount -= collateralReceived;
auction.debtToCover -= debtAmount;
if (auction.collateralAmount == 0 || auction.debtToCover == 0) {
auction.completed = true;
}
auction.liquidator = msg.sender;
emit LiquidationExecuted(
auctionId,
msg.sender,
collateralReceived,
currentPrice
);
}
event LiquidationStarted(
bytes32 indexed auctionId,
address borrower,
uint256 collateralAmount,
uint256 debtToCover
);
event LiquidationExecuted(
bytes32 indexed auctionId,
address liquidator,
uint256 collateralReceived,
uint256 price
);
}第二章：風險量化模型
2.1 市場風險因素分析
DeFi 清算風險來自於多個維度的市場風險因素。深入理解這些風險因素是建立準確量化模型的基礎。
價格波動風險
加密貨幣市場以其極端波動性著稱。比特幣和以太坊的日波動率經常達到 5-10%，而某些小型代幣的波動率可能更高。這種波動性直接影響抵押品的價值，進而影響借款人的健康因子。
# 加密貨幣波動率分析
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
class CryptoVolatilityAnalyzer:
"""
加密貨幣波動率分析器
計算歷史波動率、實現波動率和隱含波動率
"""
def __init__(self, price_data: pd.DataFrame):
"""
price_data 應包含 'timestamp' 和 'price' 列
"""
self.price_data = price_data.sort_values('timestamp')
def calculate_historical_volatility(
self,
window: int = 30,
annualize: bool = True
) -> pd.Series:
"""
計算歷史波動率
使用對數收益率的標準差
"""
# 計算對數收益率
log_returns = np.log(
self.price_data['price'] / self.price_data['price'].shift(1)
)
# 計算滾動標準差
rolling_vol = log_returns.rolling(window=window).std()
# 年化（假設 365 天）
if annualize:
rolling_vol = rolling_vol * np.sqrt(365)
return rolling_vol
def calculate_realized_volatility(
self,
returns: pd.Series,
window: int = 30
) -> float:
"""
計算實現波動率
使用 Parkinson、Garman-Klass 等估計器
"""
# Parkinson 估計器（使用高低價）
if 'high' in self.price_data.columns and 'low' in self.price_data.columns:
log_hl = np.log(
self.price_data['high'] / self.price_data['low']
)
parkinson_vol = np.sqrt(
log_hl.rolling(window).mean() / (4 * np.log(2))
)
return parkinson_vol.iloc[-1]
# 簡單標準差估計器
return returns.rolling(window).std().iloc[-1] * np.sqrt(365)
def calculate_var(
self,
returns: pd.Series,
confidence_level: float = 0.95
) -> float:
"""
計算 Value at Risk (VaR)
衡量在給定置信水平下的最大可能損失
"""
# 歷史模擬法
var = returns.quantile(1 - confidence_level)
return var
def calculate_cvar(
self,
returns: pd.Series,
confidence_level: float = 0.95
) -> float:
"""
計算 Conditional VaR (CVaR)
也稱為 Expected Shortfall
"""
var = self.calculate_var(returns, confidence_level)
cvar = returns[returns <= var].mean()
return cvar
def calculate_maximum_drawdown(self) -> float:
"""
計算最大回撤
"""
cumulative = (1 + self.price_data['price'].pct_change()).cumprod()
running_max = cumulative.expanding().max()
drawdown = (cumulative - running_max) / running_max
return drawdown.min()
def simulate_price_paths(
self,
initial_price: float,
days: int = 30,
num_simulations: int = 10000,
volatility: float = None
) -> np.ndarray:
"""
使用幾何布朗運動模擬價格路徑
"""
if volatility is None:
returns = np.log(
self.price_data['price'] / self.price_data['price'].shift(1)
).dropna()
volatility = returns.std() * np.sqrt(365)
# 假設漂移率為 0
drift = 0
# 時間增量
dt = 1 / 365
# 生成隨機路徑
random_shocks = np.random.normal(0, 1, (days, num_simulations))
# 計算價格路徑
price_paths = initial_price * np.exp(
(drift - 0.5 * volatility ** 2) * dt +
volatility * np.sqrt(dt) * random_shocks
).cumprod(axis=0)
return price_paths相關性風險
在 DeFi 借貸協議中，用戶通常使用多種資產作為抵押品。這些資產之間的相關性會影響整體風險敞口。如果所有抵押品價格同時下跌，清算風險將大大增加。
# 資產相關性分析
class AssetCorrelationAnalyzer:
"""
資產相關性分析器
計算不同加密貨幣之間的相關性矩陣
"""
def __init__(self, price_data: Dict[str, pd.DataFrame]):
"""
price_data: Dict[asset_name, price_dataframe]
"""
self.price_data = price_data
self.returns_data = self._calculate_returns()
def _calculate_returns(self) -> pd.DataFrame:
"""計算所有資產的收益率"""
returns = {}
for asset, df in self.price_data.items():
returns[asset] = np.log(
df['price'] / df['price'].shift(1)
)
return pd.DataFrame(returns)
def calculate_correlation_matrix(self) -> pd.DataFrame:
"""計算相關性矩陣"""
return self.returns_data.corr()
def calculate_covariance_matrix(self) -> pd.DataFrame:
"""計算協方差矩陣"""
return self.returns_data.cov()
def get_portfolio_volatility(
self,
weights: Dict[str, float]
) -> float:
"""
計算投資組合的波動率
"""
weights_array = np.array([
weights.get(asset, 0)
for asset in self.returns_data.columns
])
cov_matrix = self.calculate_covariance_matrix().values
portfolio_vol = np.sqrt(
weights_array @ cov_matrix @ weights_array * 365
)
return portfolio_vol
def identify_high_correlation_pairs(
self,
threshold: float = 0.7
) -> List[Tuple[str, str, float]]:
"""
識別高相關性資產對
"""
corr_matrix = self.calculate_correlation_matrix()
high_corr_pairs = []
for i in range(len(corr_matrix.columns)):
for j in range(i + 1, len(corr_matrix.columns)):
corr = corr_matrix.iloc[i, j]
if abs(corr) > threshold:
high_corr_pairs.append((
corr_matrix.columns[i],
corr_matrix.columns[j],
corr
))
return high_corr_pairs2.2 清算概率模型
清算概率是評估借貸帳戶風險的核心指標。通過量化模型，我們可以估計在特定時間範圍內觸發清算的概率。
# 清算概率計算模型
class LiquidationProbabilityModel:
"""
清算概率計算模型
使用多種方法估計清算概率
"""
def __init__(
self,
health_factor: float,
collateral_volatility: float,
time_horizon: int = 30, # 天數
confidence_level: float = 0.95
):
self.health_factor = health_factor
self.collateral_volatility = collateral_volatility
self.time_horizon = time_horizon
self.confidence_level = confidence_level
def calculate_probability_normal_approximation(
self,
current_ratio: float = None
) -> float:
"""
使用正態近似計算清算概率
假設資產價值服從對數正態分佈
"""
if current_ratio is None:
# 使用健康因子作為當前抵押率
current_ratio = self.health_factor
# 計算標準差
sigma = self.collateral_volatility * np.sqrt(self.time_horizon / 365)
# 計算清算閾值（假設為 1.0）
threshold = 1.0
# 使用正態近似
# P(value < threshold) = Φ((ln(threshold/current_ratio) + 0.5*sigma^2) / sigma)
z_score = (np.log(threshold / current_ratio) + 0.5 * sigma**2) / sigma
# 清算概率
prob_liquidation = norm.cdf(z_score)
return min(prob_liquidation, 1.0)
def calculate_probability_monte_carlo(
self,
current_collateral_value: float,
current_debt_value: float,
num_simulations: int = 10000
) -> float:
"""
使用蒙特卡羅模擬計算清算概率
"""
liquidation_count = 0
for _ in range(num_simulations):
# 模擬抵押品價值變化
random_return = np.random.normal(
0,
self.collateral_volatility * np.sqrt(self.time_horizon / 365)
)
simulated_collateral = current_collateral_value * np.exp(random_return)
# 檢查是否觸發清算
ratio = simulated_collateral / current_debt_value
if ratio < 1.0:
liquidation_count += 1
return liquidation_count / num_simulations
def calculate_expected_loss(
self,
collateral_value: float,
debt_value: float,
liquidation_penalty: float = 0.10
) -> Dict[str, float]:
"""
計算預期損失
"""
prob_liq = self.calculate_probability_normal_approximation()
# 假設清算時損失為抵押品價值的 10%（清算罰款）
loss_given_liquidation = collateral_value * liquidation_penalty
# 預期損失 = 概率 × 損失
expected_loss = prob_liq * loss_given_liquidation
# 最大可能損失
max_loss = collateral_value * liquidation_penalty
return {
'probability_of_liquidation': prob_liq,
'loss_given_liquidation': loss_given_liquidation,
'expected_loss': expected_loss,
'max_loss': max_loss,
'var_95': expected_loss * 1.645 if prob_liq > 0 else 0, # 近似 VaR
}第三章：蒙特卡羅模擬實踐
3.1 模擬框架設計
蒙特卡羅模擬是評估 DeFi 清算風險的最強大工具之一。通過生成大量可能的市場情景，我們可以估計各種風險指標，包括清算概率、預期損失和最大損失。
# DeFi 清算風險蒙特卡羅模擬框架
import numpy as np
import pandas as pd
from typing import List, Dict, Tuple
from dataclasses import dataclass
@dataclass
class LoanPosition:
"""借款倉位"""
borrower: str
collateral_assets: Dict[str, float] # asset -> amount
borrow_assets: Dict[str, float] # asset -> amount
collateral_prices: Dict[str, float] # asset -> price (USD)
borrow_prices: Dict[str, float] # asset -> price (USD)
liquidation_thresholds: Dict[str, float] # asset -> threshold
@dataclass
class SimulationResult:
"""模擬結果"""
liquidation_events: int
liquidation_probability: float
average_loss: float
percentile_5_loss: float
percentile_95_loss: float
max_loss: float
expected_collateral_value: float
final_collateral_distribution: np.ndarray
class DeFiLiquidationSimulator:
"""
DeFi 清算風險蒙特卡羅模擬器
"""
def __init__(
self,
positions: List[LoanPosition],
price_volatility: Dict[str, float], # asset -> annual volatility
price_correlation: np.ndarray, # correlation matrix
risk_free_rate: float = 0.03,
liquidation_penalty: float = 0.10
):
self.positions = positions
self.price_volatility = price_volatility
self.price_correlation = price_correlation
self.risk_free_rate = risk_free_rate
self.liquidation_penalty = liquidation_penalty
# 資產列表
self.assets = list(price_volatility.keys())
self.num_assets = len(self.assets)
# 創建相關的隨機數生成器
self.cholesky = np.linalg.cholesky(price_correlation)
def simulate_price_paths(
self,
initial_prices: Dict[str, float],
days: int = 30,
num_simulations: int = 10000
) -> Dict[str, np.ndarray]:
"""
生成相關的價格路徑
"""
# 生成獨立的標準正態隨機數
dt = days / 365
independent_normals = np.random.normal(
0, 1, (num_simulations, self.num_assets)
)
# 應用 Cholesky 分解實現相關性
correlated_normals = independent_normals @ self.cholesky.T
# 計算漂移項
drifts = (
self.risk_free_rate -
0.5 * np.array(list(self.price_volatility.values()))**2
) * dt
# 計算價格路徑
price_paths = {}
for i, asset in enumerate(self.assets):
initial = initial_prices[asset]
volatility = self.price_volatility[asset]
# 幾何布朗運動
price_paths[asset] = initial * np.exp(
drifts[i] + volatility * np.sqrt(dt) * correlated_normals[:, i]
)
return price_paths
def check_liquidation(
self,
position: LoanPosition,
prices: Dict[str, float]
) -> Tuple[bool, float]:
"""
檢查是否觸發清算
返回: (is_liquidated, loss_amount)
"""
# 計算總抵押品價值
collateral_value = sum(
amount * prices.get(asset, position.collateral_prices.get(asset, 0))
for asset, amount in position.collateral_assets.items()
)
# 計算總借款價值
borrow_value = sum(
amount * prices.get(asset, position.borrow_prices.get(asset, 0))
for asset, amount in position.borrow_assets.items()
)
# 計算健康因子
if borrow_value == 0:
return False, 0
health_factor = collateral_value / borrow_value
# 檢查是否觸發清算
if health_factor < 1.0:
# 計算清算損失
loss = collateral_value * self.liquidation_penalty
return True, loss
return False, 0
def run_simulation(
self,
days: int = 30,
num_simulations: int = 10000
) -> SimulationResult:
"""
運行蒙特卡羅模擬
"""
liquidation_count = 0
losses = []
final_collateral_values = []
# 初始價格
initial_prices = {}
for position in self.positions:
initial_prices.update(position.collateral_prices)
initial_prices.update(position.borrow_prices)
for sim in range(num_simulations):
# 生成價格路徑
final_prices = {}
for asset in self.assets:
# 簡化：只使用最終價格
initial = list(
p.collateral_prices.get(asset, p.borrow_prices.get(asset, 0))
for p in self.positions if
asset in p.collateral_prices or asset in p.borrow_prices
)
if initial and initial[0] > 0:
vol = self.price_volatility[asset]
drift = (self.risk_free_rate - 0.5 * vol**2) * days / 365
shock = np.random.normal(0, 1) * vol * np.sqrt(days / 365)
final_prices[asset] = initial[0] * np.exp(drift + shock)
# 檢查每個倉位
for position in self.positions:
is_liquidated, loss = self.check_liquidation(
position,
final_prices
)
if is_liquidated:
liquidation_count += 1
losses.append(loss)
# 記錄最終抵押品價值
collateral_value = sum(
amount * final_prices.get(
asset,
position.collateral_prices.get(asset, 0)
)
for asset, amount in position.collateral_assets.items()
)
final_collateral_values.append(collateral_value)
# 計算統計指標
liquidation_probability = liquidation_count / (num_simulations * len(self.positions))
if losses:
avg_loss = np.mean(losses)
p5_loss = np.percentile(losses, 5)
p95_loss = np.percentile(losses, 95)
max_loss = max(losses)
else:
avg_loss = 0
p5_loss = 0
p95_loss = 0
max_loss = 0
return SimulationResult(
liquidation_events=liquidation_count,
liquidation_probability=liquidation_probability,
average_loss=avg_loss,
percentile_5_loss=p5_loss,
percentile_95_loss=p95_loss,
max_loss=max_loss,
expected_collateral_value=np.mean(final_collateral_values),
final_collateral_distribution=np.array(final_collateral_values)
)
def run_stress_test(
self,
scenario: str = "crash"
) -> Dict[str, float]:
"""
壓力測試
模擬極端市場情景
"""
stress_scenarios = {
"crash": {
"ETH": -0.50,
"BTC": -0.40,
"WBTC": -0.45,
"USDC": 0.00,
"USDT": 0.00,
"DAI": 0.00,
"stETH": -0.55,
"LINK": -0.60,
},
"correlation_breakdown": {
"ETH": -0.30,
"BTC": -0.30,
"WBTC": -0.30,
"USDC": -0.05, # 穩定幣也不再穩定
"USDT": -0.05,
"DAI": -0.05,
"stETH": -0.40,
"LINK": -0.50,
},
"flash_crash": {
"ETH": -0.80,
"BTC": -0.70,
"WBTC": -0.75,
"USDC": -0.01,
"USDT": -0.01,
"DAI": -0.01,
"stETH": -0.85,
"LINK": -0.90,
}
}
scenario_returns = stress_scenarios.get(scenario, stress_scenarios["crash"])
results = {}
for position in self.positions:
# 計算壓力情景下的抵押品價值
stress_collateral_value = 0
for asset, amount in position.collateral_assets.items():
original_price = position.collateral_prices.get(asset, 0)
return_change = scenario_returns.get(asset, 0)
stress_price = original_price * (1 + return_change)
stress_collateral_value += amount * stress_price
# 計算壓力情景下的借款價值
stress_borrow_value = 0
for asset, amount in position.borrow_assets.items():
original_price = position.borrow_prices.get(asset, 0)
return_change = scenario_returns.get(asset, 0)
stress_price = original_price * (1 + return_change)
stress_borrow_value += amount * stress_price
# 計算健康因子
if stress_borrow_value > 0:
stress_health_factor = stress_collateral_value / stress_borrow_value
else:
stress_health_factor = float('inf')
# 計算損失
original_collateral_value = sum(
amount * position.collateral_prices.get(asset, 0)
for asset, amount in position.collateral_assets.items()
)
loss = original_collateral_value - stress_collateral_value
loss_pct = loss / original_collateral_value if original_collateral_value > 0 else 0
results[position.borrower] = {
"stress_health_factor": stress_health_factor,
"original_collateral_value": original_collateral_value,
"stress_collateral_value": stress_collateral_value,
"loss": loss,
"loss_percentage": loss_pct,
"liquidated": stress_health_factor < 1.0
}
return results3.2 風險評估儀表板
結合模擬結果，我們可以構建一個完整的風險評估儀表板，幫助協議營運者和投資者了解其風險敞口。
# 風險評估儀表板
class RiskDashboard:
"""
DeFi 清算風險評估儀表板
"""
def __init__(self, simulator: DeFiLiquidationSimulator):
self.simulator = simulator
def generate_full_report(
self,
days: int = 30,
num_simulations: int = 10000
) -> Dict:
"""
生成完整的風險評估報告
"""
# 運行模擬
simulation_result = self.simulator.run_simulation(
days=days,
num_simulations=num_simulations
)
# 運行壓力測試
crash_result = self.simulator.run_stress_test("crash")
correlation_result = self.simulator.run_stress_test("correlation_breakdown")
flash_crash_result = self.simulator.run_stress_test("flash_crash")
# 生成建議
recommendations = self._generate_recommendations(
simulation_result,
crash_result
)
return {
"summary": {
"liquidation_probability": simulation_result.liquidation_probability,
"expected_loss": simulation_result.average_loss,
"var_95": simulation_result.percentile_95_loss,
"max_loss": simulation_result.max_loss,
},
"monte_carlo": {
"total_simulations": num_simulations,
"liquidation_events": simulation_result.liquidation_events,
"expected_collateral_value": simulation_result.expected_collateral_value,
"final_collateral_distribution": {
"mean": np.mean(simulation_result.final_collateral_distribution),
"std": np.std(simulation_result.final_collateral_distribution),
"min": np.min(simulation_result.final_collateral_distribution),
"max": np.max(simulation_result.final_collateral_distribution),
"percentile_5": np.percentile(simulation_result.final_collateral_distribution, 5),
"percentile_25": np.percentile(simulation_result.final_collateral_distribution, 25),
"percentile_50": np.percentile(simulation_result.final_collateral_distribution, 50),
"percentile_75": np.percentile(simulation_result.final_collateral_distribution, 75),
"percentile_95": np.percentile(simulation_result.final_collateral_distribution, 95),
}
},
"stress_tests": {
"crash": {
"liquidated_count": sum(1 for r in crash_result.values() if r["liquidated"]),
"total_loss": sum(r["loss"] for r in crash_result.values()),
},
"correlation_breakdown": {
"liquidated_count": sum(1 for r in correlation_result.values() if r["liquidated"]),
"total_loss": sum(r["loss"] for r in correlation_result.values()),
},
"flash_crash": {
"liquidated_count": sum(1 for r in flash_crash_result.values() if r["liquidated"]),
"total_loss": sum(r["loss"] for r in flash_crash_result.values()),
}
},
"recommendations": recommendations
}
def _generate_recommendations(
self,
simulation_result,
stress_result: Dict
) -> List[str]:
"""
基於模擬結果生成建議
"""
recommendations = []
# 基於清算概率
if simulation_result.liquidation_probability > 0.1:
recommendations.append(
"清算風險較高：建議增加抵押品或減少借款"
)
# 基於 VaR
if simulation_result.percentile_95_loss > 10000:
recommendations.append(
"最大可能損失較高：建議設置止損或分散投資"
)
# 基於壓力測試
liquidated_in_stress = sum(1 for r in stress_result.values() if r["liquidated"])
if liquidated_in_stress > 0:
recommendations.append(
f"壓力測試顯示 {liquidated_in_stress} 個帳戶在市場崩潰時會被清算"
)
recommendations.append(
"建議提高抵押率或多元化抵押品類型"
)
return recommendations
def visualize_risk_distribution(self, result: SimulationResult):
"""
可視化風險分佈
"""
import matplotlib.pyplot as plt
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
# 1. 清算概率 vs 模擬次數
ax1 = axes[0, 0]
cumulative_liq = np.cumsum(
np.random.binomial(1, result.liquidation_probability, 10000)
) / (np.arange(10000) + 1)
ax1.plot(cumulative_liq)
ax1.axhline(y=result.liquidation_probability, color='r', linestyle='--')
ax1.set_title('Liquidation Probability Convergence')
ax1.set_xlabel('Number of Simulations')
ax1.set_ylabel('Probability')
# 2. 損失分佈直方圖
ax2 = axes[0, 1]
if len(result.final_collateral_distribution) > 0:
ax2.hist(
result.final_collateral_distribution,
bins=50,
edgecolor='black'
)
ax2.set_title('Final Collateral Value Distribution')
ax2.set_xlabel('Collateral Value (USD)')
ax2.set_ylabel('Frequency')
# 3. 風險指標
ax3 = axes[1, 0]
metrics = ['Avg Loss', 'P5 Loss', 'P95 Loss', 'Max Loss']
values = [
result.average_loss,
result.percentile_5_loss,
result.percentile_95_loss,
result.max_loss
]
ax3.bar(metrics, values)
ax3.set_title('Loss Metrics')
ax3.set_ylabel('Loss (USD)')
# 4. 風險評分雷達圖
ax4 = axes[1, 1]
categories = ['Liquidation\nProbability', 'Expected\nLoss', 'VaR', 'Max Loss']
scores = [
min(result.liquidation_probability * 10, 10),
min(result.average_loss / 10000, 10),
min(result.percentile_95_loss / 50000, 10),
min(result.max_loss / 100000, 10),
]
ax4.bar(categories, scores)
ax4.set_title('Risk Score Breakdown')
ax4.set_ylabel('Score (0-10)')
plt.tight_layout()
return fig第四章：實際案例分析
4.1 2022 年 Terra/Luna 崩潰事件
2022 年 5 月，Terra 生態系統的崩潰是 DeFi 歷史上最慘烈的清算事件之一。UST（Terra 的算法穩定幣）失去與美元的掛鉤，導致整個加密貨幣市場暴跌，DeFi 協議經歷了前所未有的清算潮。
事件回顧
事件時間線：
2022年5月9日：UST 開始脫鉤
2022年5月11日：UST 跌至 0.29 美元
2022年5月12日：LUNA 從 80 美元暴跌至 0.0001 美元
2022年5月：DeFi 協議大規模清算，總損失估計超過 40 億美元
主要受影響協議：
- Anchor Protocol：存款人損失估計 20 億美元
- DeFi 借貸協議：清算規模達數十億美元
- 交易所：被迫暫停 UST 相關交易對清算機制分析
在 Terra 崩潰期間，許多借款人的健康因子在數小時內從健康狀態降至清算閾值以下。由於市場流動性枯竭，清算人難以以合理價格清算抵押品，導致借款人遭受更大損失。
# Terra 崩潰事件的風險回測分析
class TerraCrashAnalysis:
"""
Terra 崩潰事件風險分析
"""
def __init__(self):
# 真實價格數據（簡化）
self.price_data = {
"ETH": {
"2022-05-01": 2900,
"2022-05-09": 2400,
"2022-05-12": 1700,
"2022-05-15": 2000,
},
"UST": {
"2022-05-01": 1.00,
"2022-05-09": 0.70,
"2022-05-11": 0.29,
"2022-05-12": 0.01,
},
"LUNA": {
"2022-05-01": 80,
"2022-05-09": 30,
"2022-05-12": 0.0001,
"2022-05-15": 0.00001,
}
}
def simulate_terra_liquidation(
self,
initial_collateral: float = 10000, # 初始抵押品（美元）
initial_debt: float = 5000, # 初始借款（美元）
collateral_asset: str = "ETH"
) -> Dict:
"""
模擬 Terra 崩潰期間的清算風險
"""
results = []
for date, price in self.price_data.get(collateral_asset, {}).items():
# 假設抵押品價值與 ETH 價格相關
collateral_value = initial_collateral * (price / 2900)
# 借款價值保持不變（假設借款為穩定幣）
debt_value = initial_debt
# 計算健康因子
health_factor = collateral_value / debt_value
# 記錄結果
results.append({
"date": date,
"collateral_value": collateral_value,
"debt_value": debt_value,
"health_factor": health_factor,
"liquidated": health_factor < 1.0,
"loss": max(0, collateral_value - debt_value) if health_factor < 1.0 else 0
})
return results
def calculate_realized_loss(
self,
liquidation_during_crash: bool = True
) -> Dict:
"""
計算實際損失
"""
if liquidation_during_crash:
# 清算發生在市場底部，假設回收率僅為 20%
return {
"scenario": "Liquidation during crash",
"initial_value": 10000,
"recovery_rate": 0.20,
"realized_loss": 8000,
"loss_percentage": "80%"
}
else:
# 未清算，等待回升
return {
"scenario": "Hold through crash",
"initial_value": 10000,
"current_value": 6890, # 假設 5 月 15 日價值
"unrealized_loss": 3110,
"loss_percentage": "31.1%"
}4.2 風險模型驗證
為了驗證我們的量化模型，我們可以將模型預測與歷史事件進行比較。
# 模型驗證框架
class ModelValidator:
"""
清算風險模型驗證框架
"""
def __init__(self):
self.historical_events = []
def add_historical_event(
self,
event_name: str,
date: str,
liquidation_probability_predicted: float,
liquidation_probability_actual: float,
loss_predicted: float,
loss_actual: float
):
"""添加歷史事件數據"""
self.historical_events.append({
"event_name": event_name,
"date": date,
"prob_predicted": liquidation_probability_predicted,
"prob_actual": liquidation_probability_actual,
"loss_predicted": loss_predicted,
"loss_actual": loss_actual,
})
def calculate_accuracy_metrics(self) -> Dict:
"""
計算模型準確性指標
"""
if not self.historical_events:
return {}
# 提取預測和實際值
prob_predicted = [e["prob_predicted"] for e in self.historical_events]
prob_actual = [e["prob_actual"] for e in self.historical_events]
loss_predicted = [e["loss_predicted"] for e in self.historical_events]
loss_actual = [e["loss_actual"] for e in self.historical_events]
# 計算均方根誤差（RMSE）
prob_rmse = np.sqrt(np.mean(
(np.array(prob_predicted) - np.array(prob_actual))**2
))
loss_rmse = np.sqrt(np.mean(
(np.array(loss_predicted) - np.array(loss_actual))**2
))
# 計算平均絕對百分比誤差（MAPE）
prob_mape = np.mean(np.abs(
(np.array(prob_predicted) - np.array(prob_actual)) /
np.array(prob_actual)
)) * 100
return {
"probability_rmse": prob_rmse,
"loss_rmse": loss_rmse,
"probability_mape": prob_mape,
"num_events": len(self.historical_events)
}
def backtest_model(
self,
simulator: DeFiLiquidationSimulator,
historical_scenarios: Dict
) -> Dict:
"""
回測模型
"""
results = []
for scenario_name, scenario_data in historical_scenarios.items():
# 使用歷史情景參數運行模擬
# 比較預測結果與實際結果
pass
return {
"backtest_results": results,
"summary": "Model validation complete"
}結論
DeFi 清算風險的量化分析是一個複雜但至關重要的課題。通過本文中介紹的理論框架、數學模型和程式碼實現，開發者和投資者可以更加準確地評估和管理清算風險。
關鍵要點總結：
第一，清算機制的核心是健康因子的計算。不同的借貸協議可能採用不同的計算方式，但基本原理類似：抵押品價值與借款價值的比率決定了帳戶的健康狀況。
第二，蒙特卡羅模擬是評估清算風險的最強大工具。通過生成大量可能的市場情景，我們可以估計清算概率、預期損失和最大損失等關鍵指標。
第三，壓力測試是風險管理的重要組成部分。通過模擬市場崩潰、流動性枯竭等極端情景，我們可以了解協議和投資組合在最壞情況下的表現。
第四，歷史數據驗證是確保模型準確性的關鍵步驟。通過將模型預測與歷史事件進行比較，我們可以不斷改進模型的準確性。
隨著 DeFi 生態系統的不斷發展，新的風險類型和攻擊向量將持續出現。持續監控、定期更新風險模型，並實施適當的風險緩解措施，對於保護協議和用戶資產至關重要。
參考文獻
- Aave Protocol V3 白皮書
- Compound Finance 文檔
- MakerDAO 清算機制技術文檔
- 《Quantitative Finance》期刊 - 風險管理專題
- 《Advances in Financial Machine Learning》- Marcos López de Prado
- 以太坊區塊鏈歷史交易數據
- CoinGecko 歷史價格數據
相關文章
- DeFi 借貸協議風險模擬與實際操作完整指南：從理論到實戰 — 去中心化金融借貸協議蘊含著複雜的風險，包括清算風險、智慧合約風險、利率風險、跨鏈風險等。本指南從實際操作的角度出發，提供完整的風險模擬程式碼、情境分析、以及風險管理策略。透過實際的計算和模擬，讓讀者能夠量化並理解各種風險場景，從而在參與 DeFi 借貸時做出更合理的資金管理決策。
- 新興DeFi協議安全評估框架：從基礎審查到進階量化分析 — 系統性構建DeFi協議安全評估框架，涵蓋智能合約審計、經濟模型、治理機制、流動性風險等維度。提供可直接使用的Python風險評估代碼、借貸與DEX協議的專門評估方法、以及2024-2025年安全事件數據分析。
- 以太坊 DeFi 清算事件深度實務指南：2024-2026 年最新數據與風險模擬 — 本文提供 2024-2026 年 DeFi 清算事件的完整數據分析，包括蒙特卡羅模擬器實作、健康因子預警系統、以及風險管理最佳實踐。
- 以太坊 DeFi 協議攻擊事件完整時間線資料庫：2016-2026 年重大安全事件與風險評估框架 — 本資料庫系統性地記錄了 2016 年至 2026 年間以太坊生態系統中最具影響力的安全事件，從技術層面分析攻擊手法與漏洞成因，並提供風險評估框架與防護建議。涵蓋 The DAO 攻擊、Poly Network、Ronin Bridge、Euler Finance 等重大事件，並提供開發者與投資者適用的安全檢查清單。
- DeFi 協議風險評估完整框架：從量化模型到實際案例分析 — 本文建立一個完整的 DeFi 協議風險評估框架，涵蓋風險類型分類（智能合約風險、協議設計風險、清算風險、治理風險）、量化評估方法、協議安全性審計要點、以及歷史重大風險事件深度分析。我們提供具體的評估工具、計算公式和決策框架，幫助投資者和開發者系統性地評估 DeFi 協議的風險水平。
延伸閱讀與來源
- Ethereum.org 以太坊官方入口
- EthHub 以太坊知識庫
這篇文章對您有幫助嗎？
請告訴我們如何改進：
0 人覺得有帮助
評論
發表評論
注意：由於這是靜態網站，您的評論將儲存在本地瀏覽器中，不會公開顯示。
目前尚無評論，成為第一個發表評論的人吧！