第十章：经济攻击与防御

# 经济攻击收益模型
import numpy as np
from typing import Dict, Tuple

class EconomicAttackModel:
    def __init__(self, protocol_params: Dict):
        self.liquidity = protocol_params['liquidity']
        self.fee_rate = protocol_params['fee_rate']
        self.slippage_factor = protocol_params['slippage_factor']
        self.oracle_delay = protocol_params['oracle_delay']
    
    def calculate_manipulation_profit(
        self, 
        attack_capital: float,
        market_impact: float,
        manipulation_duration: int
    ) -> Tuple[float, float]:
        """计算价格操纵攻击的潜在收益"""
        
        # 操纵成本：交易费用 + 滑点损失
        manipulation_cost = (
            attack_capital * self.fee_rate * 2 +  # 买入+卖出
            attack_capital * self.slippage_factor * market_impact
        )
        
        # 价格影响
        price_impact = market_impact * (attack_capital / self.liquidity)
        
        # 套利机会窗口
        arbitrage_window = min(manipulation_duration, self.oracle_delay)
        
        # 潜在收益：价格差 × 可套利金额
        potential_profit = price_impact * min(
            attack_capital * 0.5,  # 假设最多利用50%资金套利
            self.liquidity * 0.1   # 不能超过流动性的10%
        ) * arbitrage_window
        
        # 净收益
        net_profit = potential_profit - manipulation_cost
        
        # 成功概率（考虑MEV竞争）
        success_probability = 1 / (1 + np.exp(-arbitrage_window + 2))
        
        return net_profit, success_probability
    
    def simulate_bank_run(
        self,
        initial_redemption_rate: float,
        contagion_factor: float,
        reserve_ratio: float,
        time_steps: int = 100
    ) -> np.ndarray:
        """模拟银行挤兑场景"""
        
        redemption_history = np.zeros(time_steps)
        reserves = 1.0  # 标准化储备为1
        
        for t in range(time_steps):
            # 挤兑强度随储备减少而增加
            panic_multiplier = 1 + contagion_factor * (1 - reserves)
            
            # 当期赎回率
            current_redemption = min(
                initial_redemption_rate * panic_multiplier * (1.1 ** t),
                reserves  # 不能超过剩余储备
            )
            
            redemption_history[t] = current_redemption
            reserves -= current_redemption
            
            # 储备耗尽，系统崩溃
            if reserves <= 0:
                redemption_history[t+1:] = 0
                break
            
            # 如果储备率过低，触发死亡螺旋
            if reserves < reserve_ratio * 0.5:
                initial_redemption_rate *= 1.5
        
        return redemption_history
    
    def calculate_mev_extraction(
        self,
        transaction_value: float,
        gas_price: float,
        block_space_competition: float
    ) -> float:
        """计算MEV提取的期望收益"""
        
        # 基础MEV机会
        base_mev = transaction_value * 0.03  # 假设3%的价值可提取
        
        # 竞争因子（更多竞争者降低收益）
        competition_discount = 1 / (1 + block_space_competition)
        
        # Gas成本
        gas_cost = gas_price * 200000  # 假设复杂交易需要20万gas
        
        # 期望MEV收益
        expected_mev = base_mev * competition_discount - gas_cost
        
        return max(0, expected_mev)

# 使用示例
protocol = {
    'liquidity': 10_000_000,  # 1000万美元流动性
    'fee_rate': 0.003,        # 0.3%手续费
    'slippage_factor': 0.01,  # 1%基础滑点
    'oracle_delay': 10        # 10个区块的预言机延迟
}

model = EconomicAttackModel(protocol)

# 分析价格操纵攻击
profit, prob = model.calculate_manipulation_profit(
    attack_capital=1_000_000,  # 100万美元攻击资金
    market_impact=0.1,         # 10%市场影响
    manipulation_duration=5    # 5个区块
)

print(f"攻击净收益: ${profit:,.2f}")
print(f"成功概率: {prob:.2%}")

# 信贷/债务攻击建模
class CreditDebtAttack:
    """模拟针对MakerDAO类型系统的信贷攻击"""
    
    def __init__(self, protocol_params: dict):
        self.debt_ceiling = protocol_params['debt_ceiling']
        self.stability_fee = protocol_params['stability_fee']
        self.liquidation_ratio = protocol_params['liquidation_ratio']
        self.liquidation_penalty = protocol_params['liquidation_penalty']
        self.governance_token_supply = protocol_params['governance_token_supply']
        
    def calculate_bad_debt_creation(self, 
                                   collateral_volatility: float,
                                   attacker_capital: float,
                                   market_conditions: dict) -> dict:
        """计算恶意创建坏账的成本与影响"""
        
        # 攻击者可以开设的最大债务头寸
        max_debt_position = attacker_capital * self.liquidation_ratio
        
        # 在极端市场条件下的预期损失
        extreme_drop = market_conditions['black_swan_probability'] * market_conditions['max_drawdown']
        
        # 制造坏账的预期成本
        bad_debt_cost = max_debt_position * (extreme_drop - (1 - 1/self.liquidation_ratio))
        
        # 对系统的影响
        system_impact = {
            'bad_debt_amount': max(0, bad_debt_cost),
            'debt_ceiling_utilization': max_debt_position / self.debt_ceiling,
            'required_mkr_mint': bad_debt_cost / market_conditions['mkr_price'],  # 需要铸造的MKR
            'mkr_dilution': bad_debt_cost / (market_conditions['mkr_price'] * self.governance_token_supply)
        }
        
        return system_impact
    
    def simulate_debt_ceiling_manipulation(self, 
                                         governance_control: float,
                                         time_horizon: int) -> list:
        """模拟通过治理操纵债务上限的攻击"""
        results = []
        current_ceiling = self.debt_ceiling
        
        for t in range(time_horizon):
            # 治理提案通过概率
            proposal_success = governance_control > 0.5  # 简化：超过50%控制权
            
            if proposal_success:
                # 每次可以提高20%债务上限
                current_ceiling *= 1.2
                
                # 系统风险指标
                risk_score = self._calculate_systemic_risk(current_ceiling)
                
                results.append({
                    'time': t,
                    'debt_ceiling': current_ceiling,
                    'risk_score': risk_score,
                    'insolvency_probability': 1 - np.exp(-risk_score)
                })
        
        return results
    
    def _calculate_systemic_risk(self, debt_ceiling: float) -> float:
        """计算系统性风险评分"""
        # 债务上限相对于抵押品总价值的比率
        leverage_ratio = debt_ceiling / (debt_ceiling * self.liquidation_ratio)
        
        # 风险随杠杆指数增长
        risk_score = leverage_ratio ** 2 * 0.1
        
        return min(risk_score, 1.0)

# 使用示例
maker_params = {
    'debt_ceiling': 10_000_000_000,  # 100亿美元
    'stability_fee': 0.05,  # 5%年化
    'liquidation_ratio': 1.5,  # 150%
    'liquidation_penalty': 0.13,  # 13%
    'governance_token_supply': 1_000_000  # 100万MKR
}

attacker = CreditDebtAttack(maker_params)

# 分析坏账攻击
market_conditions = {
    'black_swan_probability': 0.01,
    'max_drawdown': 0.5,
    'mkr_price': 2000
}

impact = attacker.calculate_bad_debt_creation(
    collateral_volatility=0.8,
    attacker_capital=50_000_000,  # 5000万美元
    market_conditions=market_conditions
)

print(f"潜在坏账: ${impact['bad_debt_amount']:,.0f}")
print(f"MKR稀释: {impact['mkr_dilution']:.2%}")

# 长期资本消耗攻击模拟
class LongTermDrainAttack:
    """模拟缓慢消耗协议资本的攻击策略"""
    
    def __init__(self, protocol: dict):
        self.treasury_size = protocol['treasury_size']
        self.daily_volume = protocol['daily_volume']
        self.fee_structure = protocol['fee_structure']
        self.arbitrage_opportunities = protocol['arbitrage_opportunities']
        
    def calculate_drain_rate(self, 
                           attacker_sophistication: float,
                           market_inefficiency: float) -> dict:
        """计算资本消耗速率"""
        
        # 每日可捕获的套利机会
        daily_arbitrage = (
            self.daily_volume * 
            market_inefficiency * 
            attacker_sophistication * 
            self.arbitrage_opportunities
        )
        
        # 协议的防御能力（通过费用回收）
        protocol_recovery = self.daily_volume * self.fee_structure['base_fee']
        
        # 净消耗率
        net_drain = daily_arbitrage - protocol_recovery
        
        # 预计耗尽时间
        if net_drain > 0:
            depletion_time = self.treasury_size / net_drain
        else:
            depletion_time = float('inf')
        
        return {
            'daily_drain': net_drain,
            'drain_percentage': net_drain / self.treasury_size,
            'depletion_days': depletion_time,
            'annual_loss': net_drain * 365
        }
    
    def simulate_adaptive_attack(self, days: int) -> list:
        """模拟自适应的消耗攻击"""
        results = []
        remaining_treasury = self.treasury_size
        
        for day in range(days):
            # 攻击者根据剩余资金调整策略
            aggressiveness = 1 - (remaining_treasury / self.treasury_size)
            
            # 随着资金减少，套利机会增加（流动性降低）
            market_inefficiency = 0.001 * (1 + aggressiveness * 2)
            
            drain = self.calculate_drain_rate(
                attacker_sophistication=0.8,
                market_inefficiency=market_inefficiency
            )
            
            remaining_treasury -= drain['daily_drain']
            
            results.append({
                'day': day,
                'treasury': remaining_treasury,
                'daily_drain': drain['daily_drain'],
                'health_score': remaining_treasury / self.treasury_size
            })
            
            if remaining_treasury <= 0:
                break
        
        return results

# 示例：分析Curve等协议的长期风险
curve_protocol = {
    'treasury_size': 50_000_000,  # 5000万美元
    'daily_volume': 500_000_000,  # 5亿美元
    'fee_structure': {'base_fee': 0.0004},  # 0.04%
    'arbitrage_opportunities': 0.01  # 1%的交易存在套利机会
}

drain_attack = LongTermDrainAttack(curve_protocol)

# 分析消耗率
drain_analysis = drain_attack.calculate_drain_rate(
    attacker_sophistication=0.7,  # 中等水平攻击者
    market_inefficiency=0.002     # 0.2%市场非效率
)

print(f"每日资本消耗: ${drain_analysis['daily_drain']:,.0f}")
print(f"预计耗尽时间: {drain_analysis['depletion_days']:.0f} 天")

# 死亡螺旋的严格数学建模与稳定性分析
import numpy as np
from scipy.optimize import fsolve
from scipy.linalg import eigvals
import matplotlib.pyplot as plt

class StablecoinStabilityAnalysis:
    """稳定币系统的稳定性分析框架"""
    
    def __init__(self, params: dict):
        self.alpha = params['alpha']  # 基本面权重
        self.beta = params['beta']    # 预期权重
        self.gamma = params['gamma']  # 供应冲击系数
        self.mu = params['mu']        # 铸币率
        self.rho = params['rho']      # 赎回率
        
    def state_transition(self, state: np.ndarray, expectation: float) -> np.ndarray:
        """
        状态转移函数
        state = [P_t, S_t, R_t]
        """
        P, S, R = state
        
        # 价格动态（包含反身性）
        P_next = self.alpha * R / S + self.beta * expectation - self.gamma * self.mu * (1 - P) * S
        
        # 供应动态
        S_next = S + self.mu * (1 - P) * S
        
        # 储备动态
        R_next = R - self.rho * (1 - P) * S
        
        return np.array([P_next, S_next, R_next])
    
    def find_equilibrium(self, initial_guess: np.ndarray) -> np.ndarray:
        """寻找系统平衡点"""
        def equilibrium_condition(state):
            P, S, R = state
            next_state = self.state_transition(state, P)  # 理性预期：E[P_t+1] = P_t
            return next_state - state
        
        equilibrium = fsolve(equilibrium_condition, initial_guess)
        return equilibrium
    
    def linearize_around_equilibrium(self, equilibrium: np.ndarray) -> np.ndarray:
        """在平衡点附近线性化，计算雅可比矩阵"""
        P_eq, S_eq, R_eq = equilibrium
        
        # 雅可比矩阵
        J = np.array([
            [self.beta - self.gamma * self.mu * S_eq, 
             -self.alpha * R_eq / S_eq**2 - self.gamma * self.mu * (1 - P_eq),
             self.alpha / S_eq],
            [self.mu * S_eq, 
             self.mu * (1 - P_eq), 
             0],
            [-self.rho * S_eq, 
             -self.rho * (1 - P_eq), 
             1]
        ])
        
        return J
    
    def check_lyapunov_stability(self, equilibrium: np.ndarray) -> dict:
        """使用Lyapunov方法检查稳定性"""
        J = self.linearize_around_equilibrium(equilibrium)
        eigenvalues = eigvals(J)
        
        # 定义Lyapunov函数 V(x) = x^T P x
        # 其中P是正定矩阵，满足Lyapunov方程：J^T P + P J = -Q
        
        stability_results = {
            'eigenvalues': eigenvalues,
            'max_real_part': np.max(np.real(eigenvalues)),
            'is_stable': np.all(np.real(eigenvalues) < 0),
            'stability_margin': -np.max(np.real(eigenvalues)) if np.all(np.real(eigenvalues) < 0) else 0
        }
        
        return stability_results
    
    def simulate_death_spiral(self, initial_state: np.ndarray, 
                            shock_magnitude: float, 
                            time_steps: int = 100) -> dict:
        """模拟死亡螺旋过程"""
        states = np.zeros((time_steps, 3))
        states[0] = initial_state
        
        # 施加初始冲击
        states[0, 0] *= (1 - shock_magnitude)  # 价格冲击
        
        # 预期形成机制（自适应预期）
        expectations = np.zeros(time_steps)
        expectations[0] = states[0, 0]
        
        for t in range(1, time_steps):
            # 更新预期（加权平均）
            expectations[t] = 0.7 * states[t-1, 0] + 0.3 * expectations[t-1]
            
            # 状态转移
            states[t] = self.state_transition(states[t-1], expectations[t])
            
            # 检查崩溃条件
            if states[t, 0] < 0.1 or states[t, 2] < 0:  # 价格接近0或储备耗尽
                states[t:] = states[t]  # 系统崩溃，状态不再变化
                break
        
        return {
            'states': states,
            'expectations': expectations,
            'collapse_time': t if t < time_steps - 1 else None
        }

# 参数校准（基于历史数据）
params = {
    'alpha': 0.6,   # 基本面权重
    'beta': 0.3,    # 预期权重
    'gamma': 0.05,  # 供应冲击系数
    'mu': 0.1,      # 铸币率
    'rho': 0.15     # 赎回率
}

# 创建分析实例
analyzer = StablecoinStabilityAnalysis(params)

# 寻找平衡点
equilibrium = analyzer.find_equilibrium([1.0, 1000, 1000])
print(f"系统平衡点: P={equilibrium[0]:.3f}, S={equilibrium[1]:.0f}, R={equilibrium[2]:.0f}")

# 稳定性分析
stability = analyzer.check_lyapunov_stability(equilibrium)
print(f"系统稳定性: {'稳定' if stability['is_stable'] else '不稳定'}")
print(f"稳定性裕度: {stability['stability_margin']:.4f}")

# 模拟20%价格冲击
simulation = analyzer.simulate_death_spiral(equilibrium, shock_magnitude=0.2)
if simulation['collapse_time']:
    print(f"系统在第{simulation['collapse_time']}期崩溃")

# UST/LUNA死亡螺旋量化模型
import numpy as np
import matplotlib.pyplot as plt
from typing import Tuple, List

class DeathSpiralModel:
    """
    模拟UST/LUNA式的算法稳定币死亡螺旋
    """
    def __init__(self, initial_params: dict):
        self.ust_supply = initial_params['ust_supply']  # UST总供应
        self.luna_price = initial_params['luna_price']  # LUNA初始价格
        self.luna_supply = initial_params['luna_supply']  # LUNA总供应
        self.market_liquidity = initial_params['market_liquidity']  # 市场流动性
        self.panic_threshold = initial_params['panic_threshold']  # 恐慌阈值
        
    def calculate_luna_mint_amount(self, ust_burn: float, ust_price: float) -> float:
        """
        计算燃烧UST后铸造的LUNA数量
        公式: LUNA_minted = UST_burned / (UST_price * LUNA_price)
        """
        return ust_burn / (ust_price * self.luna_price)
    
    def calculate_price_impact(self, luna_sold: float) -> float:
        """
        计算大量抛售LUNA对价格的影响
        使用幂函数模型: Impact = (luna_sold / liquidity) ^ 2
        """
        liquidity_ratio = luna_sold / self.market_liquidity
        return liquidity_ratio ** 2
    
    def simulate_death_spiral(
        self, 
        initial_depeg: float,
        arbitrageur_capital: float,
        time_steps: int = 100
    ) -> Tuple[List[float], List[float], List[float]]:
        """
        模拟完整的死亡螺旋过程
        """
        ust_prices = [1 - initial_depeg]
        luna_prices = [self.luna_price]
        luna_supplies = [self.luna_supply]
        
        for t in range(time_steps):
            current_ust_price = ust_prices[-1]
            
            # 套利者利用脱钅机会
            if current_ust_price < 0.99:  # UST价格低于0.99美元
                # 计算套利金额
                arbitrage_amount = min(
                    arbitrageur_capital * (0.99 - current_ust_price),
                    self.ust_supply * 0.01  # 每次最多套利总供应的1%
                )
                
                # 燃烧UST，铸造LUNA
                luna_minted = self.calculate_luna_mint_amount(
                    arbitrage_amount, 
                    current_ust_price
                )
                self.luna_supply += luna_minted
                self.ust_supply -= arbitrage_amount
                
                # 套利者在市场上抛售LUNA
                price_impact = self.calculate_price_impact(luna_minted)
                self.luna_price *= (1 - price_impact)
                
                # LUNA价格下跌引发更多恐慌
                if self.luna_price < self.panic_threshold:
                    # 恐慌性抛售加剧
                    panic_selling = self.luna_supply * 0.05  # 5%的持有者恐慌抛售
                    additional_impact = self.calculate_price_impact(panic_selling)
                    self.luna_price *= (1 - additional_impact)
                
                # UST脱钅加剧（由于LUNA价值下跌，背书不足）
                luna_market_cap = self.luna_price * self.luna_supply
                backing_ratio = luna_market_cap / self.ust_supply
                
                # 新的UST价格取决于背书比率
                new_ust_price = min(0.99, backing_ratio * 0.95)  # 假设5场对背书有一定信心
                
            else:
                new_ust_price = min(1.0, current_ust_price + 0.001)  # 缓慢恢复
            
            ust_prices.append(new_ust_price)
            luna_prices.append(self.luna_price)
            luna_supplies.append(self.luna_supply)
            
            # 终止条件：LUNA价格归零或UST完全崩溃
            if self.luna_price < 0.01 or new_ust_price < 0.1:
                print(f"\u6b7b亡螺旋完成，系统在第{t}步崩溃")
                break
        
        return ust_prices, luna_prices, luna_supplies
    
    def analyze_critical_points(self) -> dict:
        """
        分析系统的关键参数和临界点
        """
        # 最小可持续背书比率
        min_backing_ratio = 1.5  # 假设需要150%的超额抵押
        
        # 最大可承受的脱钅幅度
        max_depeg = 0.05  # 5%
        
        # 触发死亡螺旋的LUNA价格阈值
        critical_luna_price = (self.ust_supply * min_backing_ratio) / self.luna_supply
        
        return {
            'min_backing_ratio': min_backing_ratio,
            'max_sustainable_depeg': max_depeg,
            'critical_luna_price': critical_luna_price,
            'current_backing_ratio': (self.luna_price * self.luna_supply) / self.ust_supply
        }

# 使用示例
params = {
    'ust_supply': 18_000_000_000,   # 180亿 UST
    'luna_price': 80,                # LUNA初始价格80美元
    'luna_supply': 350_000_000,      # 3.5亿 LUNA
    'market_liquidity': 500_000_000, # 5亿美元流动性
    'panic_threshold': 50            # 价格低于50美元时触发恐慌
}

model = DeathSpiralModel(params)
critical_points = model.analyze_critical_points()

print(f"关键参数分析:")
print(f"当前背书比率: {critical_points['current_backing_ratio']:.2f}")
print(f"触发死亡螺旋的LUNA价格: ${critical_points['critical_luna_price']:.2f}")

# 模拟10%脱钅情况
ust_prices, luna_prices, luna_supplies = model.simulate_death_spiral(
    initial_depeg=0.10,      # 10%脱钅
    arbitrageur_capital=1_000_000_000,  # 10亿美元套利资金
    time_steps=50
)

# 可视化结果
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 12))

# UST价格
ax1.plot(ust_prices, 'b-', linewidth=2)
ax1.axhline(y=1, color='r', linestyle='--', label='锚定价格')
ax1.set_ylabel('UST 价格 (USD)')
ax1.set_title('UST 脱锚过程')
ax1.grid(True, alpha=0.3)
ax1.legend()

# LUNA价格
ax2.plot(luna_prices, 'g-', linewidth=2)
ax2.set_ylabel('LUNA 价格 (USD)')
ax2.set_title('LUNA 价格崩溃')
ax2.grid(True, alpha=0.3)

# LUNA供应量
ax3.plot(luna_supplies, 'orange', linewidth=2)
ax3.set_ylabel('LUNA 供应量')
ax3.set_xlabel('时间步')
ax3.set_title('LUNA 供应量膨胀')
ax3.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# 稳定币博弈论模型
import numpy as np
from scipy.optimize import minimize
from typing import List, Tuple

class StablecoinGameTheory:
    def __init__(self):
        self.players = ['holder', 'arbitrageur', 'attacker', 'protocol']
    
    def calculate_nash_equilibrium(
        self,
        payoff_matrix: np.ndarray
    ) -> Tuple[np.ndarray, np.ndarray]:
        """计算纳什均衡"""
        n_strategies = payoff_matrix.shape[0]
        
        # 设置线性规划问题
        c = np.zeros(n_strategies + 1)
        c[-1] = -1  # 最大化期望收益
        
        # 约束条件
        A_ub = np.column_stack((-payoff_matrix.T, np.ones(n_strategies)))
        b_ub = np.zeros(n_strategies)
        
        A_eq = np.zeros((1, n_strategies + 1))
        A_eq[0, :n_strategies] = 1
        b_eq = np.array([1])
        
        bounds = [(0, 1) for _ in range(n_strategies)] + [(None, None)]
        
        # 求解
        result = minimize(
            lambda x: -x[-1],
            x0=np.ones(n_strategies + 1) / n_strategies,
            method='SLSQP',
            bounds=bounds,
            constraints=[
                {'type': 'ineq', 'fun': lambda x: A_ub @ x - b_ub},
                {'type': 'eq', 'fun': lambda x: A_eq @ x - b_eq}
            ]
        )
        
        strategy = result.x[:n_strategies]
        value = -result.fun
        
        return strategy, value
    
    def bank_run_game(
        self,
        reserve_ratio: float,
        n_depositors: int,
        stablecoin_params: dict = None
    ) -> Dict[str, float]:
        """
        增强的Diamond-Dybvig模型，融入稳定币特定参数
        
        参数映射:
        - R (长期投资回报) -> staking_yield (质押收益率)
        - L (短期取款惩罚) -> redemption_fee (赎回费用)
        - p (恐慌概率) -> 基于链上指标计算
        """
        
        # 默认参数
        if stablecoin_params is None:
            stablecoin_params = {
                'staking_yield': 0.05,      # 5% APY
                'redemption_fee': 0.003,    # 0.3% 赎回费
                'collateral_ratio': 1.5,    # 150% 抵押率
                'liquidation_penalty': 0.13  # 13% 清算罚金
            }
        
        # 从稳定币参数计算博弈参数
        early_withdrawal_penalty = stablecoin_params['redemption_fee']
        late_withdrawal_bonus = stablecoin_params['staking_yield'] / 12  # 按月计
        
        # 计算临界点
        # 如果提取的人数超过临界点，银行破产
        critical_withdrawals = int(reserve_ratio * n_depositors)
        
        results = {}
        
        # 模拟不同提取比例下的收益
        for withdraw_ratio in np.linspace(0, 1, 21):
            n_withdraw = int(withdraw_ratio * n_depositors)
            
            if n_withdraw <= critical_withdrawals:
                # 银行存活
                payoff_withdraw = 1 - early_withdrawal_penalty
                payoff_stay = 1 + late_withdrawal_bonus
            else:
                # 银行破产
                # 早期提取者按比例获得储备
                payoff_withdraw = reserve_ratio / withdraw_ratio if withdraw_ratio > 0 else 0
                # 留存者损失全部
                payoff_stay = 0
            
            # 期望收益
            expected_payoff = (
                withdraw_ratio * payoff_withdraw + 
                (1 - withdraw_ratio) * payoff_stay
            )
            
            results[f"{withdraw_ratio:.0%}_withdraw"] = {
                'withdraw_payoff': payoff_withdraw,
                'stay_payoff': payoff_stay,
                'expected_payoff': expected_payoff,
                'is_bank_run': n_withdraw > critical_withdrawals
            }
        
        return results
    
    def calculate_attack_defense_equilibrium(
        self,
        attack_cost: float,
        defense_cost: float,
        system_value: float,
        attack_success_rate: float
    ) -> Dict[str, float]:
        """攻防博弈均衡分析"""
        
        # 收益矩阵
        # 行：攻击者策略（攻击/不攻击）
        # 列：防御者策略（防御/不防御）
        payoff_attacker = np.array([
            [
                attack_success_rate * system_value - attack_cost,  # 攻击vs防御
                system_value - attack_cost                         # 攻击vs不防御
            ],
            [0, 0]  # 不攻击
        ])
        
        payoff_defender = np.array([
            [
                -defense_cost,                                      # 防御vs攻击
                -system_value                                       # 不防御vs攻击
            ],
            [-defense_cost, 0]  # vs不攻击
        ])
        
        # 混合策略纳什均衡
        # p = 防御概率，q = 攻击概率
        p_defend = attack_cost / (system_value * (1 - attack_success_rate))
        q_attack = defense_cost / (system_value * (1 - attack_success_rate))
        
        # 确保概率在[0,1]范围内
        p_defend = np.clip(p_defend, 0, 1)
        q_attack = np.clip(q_attack, 0, 1)
        
        return {
            'defense_probability': p_defend,
            'attack_probability': q_attack,
            'expected_loss': q_attack * (1 - p_defend) * system_value,
            'defense_efficiency': 1 - (q_attack * (1 - p_defend))
        }

# 使用示例
game = StablecoinGameTheory()

# 分析银行挤兑
bank_run_results = game.bank_run_game(
    reserve_ratio=0.2,  # 20%准备金率
    n_depositors=1000   # 1000个存款人
)

# 找出均衡点
for ratio, result in bank_run_results.items():
    if result['is_bank_run']:
        print(f"Bank run triggered at {ratio}")
        break

# 攻防博弈分析
equilibrium = game.calculate_attack_defense_equilibrium(
    attack_cost=100_000,
    defense_cost=50_000,
    system_value=10_000_000,
    attack_success_rate=0.3
)

print(f"最优防御概率: {equilibrium['defense_probability']:.2%}")
print(f"预期攻击概率: {equilibrium['attack_probability']:.2%}")

// 自适应防御系统
contract AdaptiveDefenseSystem {
    
    // 风险参数
    struct RiskParameters {
        uint256 maxSlippage;          // 最大滑点
        uint256 maxTransactionSize;    // 最大交易规模
        uint256 cooldownPeriod;        // 冷却期
        uint256 liquidationThreshold;  // 清算阈值
        uint256 borrowingRate;         // 借贷利率
    }
    
    RiskParameters public params;
    
    // 市场状态指标
    struct MarketMetrics {
        uint256 volatility;
        uint256 liquidity;
        uint256 utilizationRate;
        uint256 defaultRate;
        uint256 lastUpdateTime;
    }
    
    MarketMetrics public metrics;
    
    // 动态调整参数
    function updateRiskParameters() external {
        require(
            block.timestamp >= metrics.lastUpdateTime + 1 hours,
            "Too soon to update"
        );
        
        // 基于市场状态计算风险等级
        uint256 riskScore = calculateRiskScore();
        
        // 高风险状态：收紧参数
        if (riskScore > 80) {
            params.maxSlippage = 100;           // 1%
            params.maxTransactionSize = 100000 * 1e18;  // 10万
            params.cooldownPeriod = 1 hours;
            params.liquidationThreshold = 8500; // 85%
            params.borrowingRate = 2000;        // 20% APR
        }
        // 中等风险状态
        else if (riskScore > 50) {
            params.maxSlippage = 300;           // 3%
            params.maxTransactionSize = 500000 * 1e18;  // 50万
            params.cooldownPeriod = 30 minutes;
            params.liquidationThreshold = 8000; // 80%
            params.borrowingRate = 1000;        // 10% APR
        }
        // 低风险状态：放松参数
        else {
            params.maxSlippage = 500;           // 5%
            params.maxTransactionSize = 1000000 * 1e18; // 100万
            params.cooldownPeriod = 10 minutes;
            params.liquidationThreshold = 7500; // 75%
            params.borrowingRate = 500;         // 5% APR
        }
        
        metrics.lastUpdateTime = block.timestamp;
        emit ParametersUpdated(riskScore, params);
    }
    
    function calculateRiskScore() internal view returns (uint256) {
        uint256 score = 0;
        
        // 波动性评分（0-40分）
        score += min(40, metrics.volatility / 100);
        
        // 流动性评分（0-30分）
        score += 30 - min(30, metrics.liquidity / 1000000);
        
        // 利用率评分（0-20分）
        if (metrics.utilizationRate > 9000) {  // >90%
            score += 20;
        } else if (metrics.utilizationRate > 8000) {  // >80%
            score += 10;
        }
        
        // 违约率评分（0-10分）
        score += min(10, metrics.defaultRate * 10);
        
        return score;
    }
}

// 熔断机制
contract CircuitBreakerV2 {
    enum BreakLevel { NONE, YELLOW, ORANGE, RED }
    BreakLevel public currentLevel = BreakLevel.NONE;
    
    uint256 public constant YELLOW_THRESHOLD = 5;   // 5%价格偏离
    uint256 public constant ORANGE_THRESHOLD = 10;  // 10%价格偏离
    uint256 public constant RED_THRESHOLD = 20;     // 20%价格偏离
    
    mapping(address => uint256) public userCooldowns;
    
    modifier checkCircuitBreaker() {
        if (currentLevel == BreakLevel.RED) {
            revert("System halted");
        }
        
        if (currentLevel == BreakLevel.ORANGE) {
            require(
                userCooldowns[msg.sender] < block.timestamp,
                "User in cooldown"
            );
            userCooldowns[msg.sender] = block.timestamp + 1 hours;
        }
        
        if (currentLevel == BreakLevel.YELLOW) {
            require(
                msg.value <= 10000 * 1e18,
                "Transaction size limited"
            );
        }
        
        _;
    }
    
    function updateBreakLevel(uint256 priceDeviation) external {
        if (priceDeviation >= RED_THRESHOLD) {
            currentLevel = BreakLevel.RED;
            emit EmergencyStop(block.timestamp);
        } else if (priceDeviation >= ORANGE_THRESHOLD) {
            currentLevel = BreakLevel.ORANGE;
        } else if (priceDeviation >= YELLOW_THRESHOLD) {
            currentLevel = BreakLevel.YELLOW;
        } else {
            currentLevel = BreakLevel.NONE;
        }
    }
}

// 1. crvUSD的LLAMMA（软清算）机制
contract SoftLiquidationAMM {
    struct Position {
        uint256 collateral;     // ETH抵押品
        uint256 debt;          // crvUSD债务
        uint256 n1;            // 价格带下限
        uint256 n2;            // 价格带上限
        uint256 liquidationDiscount;
    }
    
    mapping(address => Position) public positions;
    uint256 public constant A = 100;  // 放大参数
    uint256 public constant BANDS = 50;  // 价格带数量
    
    function deposit(uint256 collateralAmount, uint256 debtAmount) external {
        // 计算用户的价格带范围
        uint256 currentPrice = getOraclePrice();
        uint256 n1 = calculateN1(collateralAmount, debtAmount, currentPrice);
        uint256 n2 = n1 + calculateBands(collateralAmount, debtAmount);
        
        positions[msg.sender] = Position({
            collateral: collateralAmount,
            debt: debtAmount,
            n1: n1,
            n2: n2,
            liquidationDiscount: 60  // 6%
        });
    }
    
    // 软清算：根据价格自动转换抵押品
    function softLiquidate(address user) external {
        Position storage pos = positions[user];
        uint256 currentPrice = getOraclePrice();
        uint256 currentBand = getPriceBand(currentPrice);
        
        if (currentBand >= pos.n1 && currentBand <= pos.n2) {
            // 在清算范围内，部分转换
            uint256 fraction = calculateConversionFraction(
                currentBand,
                pos.n1,
                pos.n2
            );
            
            uint256 collateralToSell = (pos.collateral * fraction) / 1e18;
            uint256 stablecoinReceived = (collateralToSell * currentPrice * 
                (10000 - pos.liquidationDiscount)) / 10000 / 1e18;
            
            // 更新位置
            pos.collateral -= collateralToSell;
            pos.debt -= stablecoinReceived;
            
            emit SoftLiquidation(user, collateralToSell, stablecoinReceived);
        }
    }
    
    // 计算转换比例（基于Bonding Curve）
    function calculateConversionFraction(
        uint256 currentBand,
        uint256 n1,
        uint256 n2
    ) internal pure returns (uint256) {
        uint256 relativePosition = ((currentBand - n1) * 1e18) / (n2 - n1);
        // 使用sigmoid函数平滑过渡
        return 1e18 / (1 + exp(-int256(relativePosition - 5e17) / 1e17));
    }
}

// 2. 速率限制器（Rate Limiter）
contract RateLimiter {
    struct Bucket {
        uint256 capacity;
        uint256 tokens;
        uint256 refillRate;
        uint256 lastRefillTime;
    }
    
    mapping(address => Bucket) public userBuckets;
    mapping(bytes4 => Bucket) public functionBuckets;
    
    modifier rateLimited(uint256 tokensRequired) {
        Bucket storage bucket = userBuckets[msg.sender];
        
        // 补充令牌
        uint256 elapsed = block.timestamp - bucket.lastRefillTime;
        uint256 tokensToAdd = (elapsed * bucket.refillRate) / 1e18;
        bucket.tokens = min(bucket.capacity, bucket.tokens + tokensToAdd);
        bucket.lastRefillTime = block.timestamp;
        
        // 检查令牌
        require(bucket.tokens >= tokensRequired, "Rate limit exceeded");
        bucket.tokens -= tokensRequired;
        
        _;
    }
    
    // 动态调整速率限制
    function adjustRateLimit(address user, uint256 riskScore) external {
        Bucket storage bucket = userBuckets[user];
        
        if (riskScore > 80) {
            // 高风险：严格限制
            bucket.capacity = 10;
            bucket.refillRate = 1e17;  // 0.1 tokens/second
        } else if (riskScore > 50) {
            // 中等风险
            bucket.capacity = 50;
            bucket.refillRate = 5e17;  // 0.5 tokens/second
        } else {
            // 低风险
            bucket.capacity = 100;
            bucket.refillRate = 1e18;  // 1 token/second
        }
    }
}

// 3. 动态抵押率系统
contract DynamicCollateralRatio {
    uint256 public baseRatio = 15000;  // 150%
    uint256 public volatilityMultiplier = 100;  // 1%
    
    struct MarketConditions {
        uint256 volatility30d;
        uint256 liquidityDepth;
        uint256 correlationIndex;
        uint256 systemUtilization;
    }
    
    function calculateDynamicRatio(
        address collateralAsset,
        MarketConditions memory conditions
    ) public view returns (uint256) {
        uint256 ratio = baseRatio;
        
        // 波动率调整
        ratio += (conditions.volatility30d * volatilityMultiplier) / 100;
        
        // 流动性调整
        if (conditions.liquidityDepth < 1000000 * 1e18) {
            ratio += 500;  // 低流动性+5%
        }
        
        // 相关性调整（高相关性资产需要更高抵押）
        ratio += (conditions.correlationIndex * 10);
        
        // 系统利用率调整
        if (conditions.systemUtilization > 8000) {  // >80%
            ratio += 1000;  // +10%
        }
        
        return ratio;
    }
}

// 危机响应系统
interface CrisisLevel {
    level: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
    triggers: string[];
    actions: string[];
    authority: string[];
}

class CrisisResponseSystem {
    private crisisLevels: Map = new Map();
    private currentLevel: string = 'LOW';
    private responseTeam: string[] = [];
    
    constructor() {
        this.initializeCrisisLevels();
    }
    
    private initializeCrisisLevels() {
        // 低级危机
        this.crisisLevels.set('LOW', {
            level: 'LOW',
            triggers: [
                'Price deviation > 3%',
                'Unusual trading volume',
                'Minor smart contract bug'
            ],
            actions: [
                'Monitor closely',
                'Alert core team',
                'Prepare response plan'
            ],
            authority: ['monitoring_team']
        });
        
        // 中级危机
        this.crisisLevels.set('MEDIUM', {
            level: 'MEDIUM',
            triggers: [
                'Price deviation > 5%',
                'Liquidity drop > 20%',
                'Governance attack attempt'
            ],
            actions: [
                'Activate defense mechanisms',
                'Limit transaction sizes',
                'Increase collateral requirements'
            ],
            authority: ['core_team', 'security_team']
        });
        
        // 高级危机
        this.crisisLevels.set('HIGH', {
            level: 'HIGH',
            triggers: [
                'Price deviation > 10%',
                'Bank run detected',
                'Critical vulnerability found'
            ],
            actions: [
                'Pause non-essential functions',
                'Activate insurance fund',
                'Emergency governance vote'
            ],
            authority: ['emergency_council', 'multisig_signers']
        });
        
        // 关键危机
        this.crisisLevels.set('CRITICAL', {
            level: 'CRITICAL',
            triggers: [
                'System compromise',
                'Complete depeg',
                'Catastrophic loss'
            ],
            actions: [
                'Full system pause',
                'Asset recovery mode',
                'Legal team activation',
                'Public communication'
            ],
            authority: ['founder_keys', 'legal_team']
        });
    }
    
    async detectCrisis(metrics: SystemMetrics): Promise {
        // 检查各级触发条件
        for (const [levelName, level] of this.crisisLevels) {
            for (const trigger of level.triggers) {
                if (await this.evaluateTrigger(trigger, metrics)) {
                    return level;
                }
            }
        }
        return null;
    }
    
    async respondToCrisis(crisis: CrisisLevel) {
        console.log(`Crisis detected: ${crisis.level}`);
        
        // 执行响应动作
        for (const action of crisis.actions) {
            await this.executeAction(action);
        }
        
        // 通知相关方
        await this.notifyStakeholders(crisis);
        
        // 启动恢复计划
        if (crisis.level === 'HIGH' || crisis.level === 'CRITICAL') {
            await this.initiateRecoveryPlan();
        }
    }
    
    private async executeAction(action: string) {
        const actionMap: { [key: string]: () => Promise } = {
            'Pause non-essential functions': async () => {
                await this.pauseContracts(['swap', 'lend', 'stake']);
            },
            'Activate insurance fund': async () => {
                await this.activateInsurance();
            },
            'Full system pause': async () => {
                await this.emergencyPause();
            },
            'Asset recovery mode': async () => {
                await this.enableRecoveryMode();
            }
        };
        
        const actionFunction = actionMap[action];
        if (actionFunction) {
            await actionFunction();
        }
    }
    
    private async initiateRecoveryPlan() {
        const recoverySteps = [
            'Assess damage',
            'Secure remaining assets',
            'Calculate user balances',
            'Prepare compensation plan',
            'Deploy recovery contracts',
            'Enable gradual withdrawal',
            'Monitor recovery progress'
        ];
        
        for (const step of recoverySteps) {
            console.log(`Executing recovery step: ${step}`);
            await this.executeRecoveryStep(step);
        }
    }
}

// 事后分析框架
class PostMortemAnalysis {
    async analyzeIncident(incidentId: string): Promise {
        const incident = await this.loadIncidentData(incidentId);
        
        return {
            summary: this.generateSummary(incident),
            timeline: this.constructTimeline(incident),
            rootCause: await this.identifyRootCause(incident),
            impact: this.assessImpact(incident),
            lessons: this.extractLessons(incident),
            improvements: this.recommendImprovements(incident)
        };
    }
    
    private async identifyRootCause(incident: IncidentData): Promise {
        // 5 Whys分析法
        const whys: string[] = [];
        let currentIssue = incident.initialIssue;
        
        for (let i = 0; i < 5; i++) {
            const why = await this.askWhy(currentIssue);
            whys.push(why);
            currentIssue = why;
            
            // 如果找到根本原因，提前结束
            if (this.isRootCause(why)) {
                break;
            }
        }
        
        return {
            issue: incident.initialIssue,
            whys: whys,
            rootCause: whys[whys.length - 1],
            category: this.categorizeRootCause(whys[whys.length - 1])
        };
    }
    
    private recommendImprovements(incident: IncidentData): Improvement[] {
        const improvements: Improvement[] = [];
        
        // 技术改进
        if (incident.category === 'technical') {
            improvements.push({
                area: 'Smart Contract',
                recommendation: 'Implement additional validation checks',
                priority: 'HIGH',
                effort: 'MEDIUM'
            });
        }
        
        // 流程改进
        improvements.push({
            area: 'Monitoring',
            recommendation: 'Add real-time alerts for similar patterns',
            priority: 'HIGH',
            effort: 'LOW'
        });
        
        // 治理改进
        if (incident.severity === 'HIGH') {
            improvements.push({
                area: 'Governance',
                recommendation: 'Review and update emergency procedures',
                priority: 'MEDIUM',
                effort: 'MEDIUM'
            });
        }
        
        return improvements;
    }
}