第八章：收益策略

import numpy as np
import pandas as pd
from typing import Dict, List, Tuple, Optional
from scipy.optimize import minimize_scalar

class AdvancedYieldCalculator:
    """高级稳定币收益计算器"""
    
    @staticmethod
    def calculate_apy(apr: float, compounds_per_year: int = 365) -> float:
        """
        将APR转换为APY（标准公式）
        
        Args:
            apr: 年化百分比率 (0.05 = 5%)
            compounds_per_year: 每年复利次数
            
        Returns:
            apy: 年化百分比收益率
        """
        return (1 + apr / compounds_per_year) ** compounds_per_year - 1
    
    @staticmethod
    def continuous_compound_apy(apr: float) -> float:
        """计算连续复利的APY（理论上限）"""
        return np.exp(apr) - 1
    
    @staticmethod
    def calculate_vector_apr(yield_sources: Dict[str, float], 
                           weights: Optional[Dict[str, float]] = None) -> Dict[str, float]:
        """
        计算多源收益的向量APR
        
        Args:
            yield_sources: 各收益来源的APR
            weights: 各收益源的权重（可选）
            
        Returns:
            综合收益指标
        """
        if weights is None:
            weights = {k: 1.0 for k in yield_sources.keys()}
        
        # 计算加权APR
        weighted_apr = sum(apr * weights.get(source, 1.0) 
                          for source, apr in yield_sources.items())
        
        # 计算各组成部分贡献
        contributions = {
            source: apr * weights.get(source, 1.0) / weighted_apr 
            for source, apr in yield_sources.items()
        }
        
        return {
            'total_apr': weighted_apr,
            'components': yield_sources,
            'contributions': contributions,
            'risk_adjusted_apr': weighted_apr * 0.8  # 简化的风险调整
        }
    
    @staticmethod
    def optimal_compound_frequency(
        principal: float,
        apr: float,
        gas_cost_usd: float,
        gas_price_gwei: float = 30,
        eth_price: float = 2000
    ) -> Dict[str, float]:
        """
        计算考虑Gas成本的最优复利频率
        
        Args:
            principal: 本金（USD）
            apr: 年化利率
            gas_cost_usd: 每次复利操作的Gas成本
            gas_price_gwei: Gas价格
            eth_price: ETH价格
            
        Returns:
            最优复利频率和相关指标
        """
        def net_profit(compounds_per_year):
            if compounds_per_year < 1:
                return -float('inf')
            
            # 复利收益
            gross_return = principal * ((1 + apr/compounds_per_year)**compounds_per_year - 1)
            
            # Gas成本
            total_gas_cost = compounds_per_year * gas_cost_usd
            
            # 净收益
            return gross_return - total_gas_cost
        
        # 寻找最优频率
        result = minimize_scalar(
            lambda x: -net_profit(x),
            bounds=(1, 365),
            method='bounded'
        )
        
        optimal_frequency = int(result.x)
        optimal_net_return = -result.fun
        
        # 计算不同频率下的收益对比
        frequencies = [1, 12, 52, 365]  # 年、月、周、日
        comparisons = {}
        
        for freq in frequencies:
            gross = principal * ((1 + apr/freq)**freq - 1)
            gas = freq * gas_cost_usd
            net = gross - gas
            comparisons[f'{freq}x/year'] = {
                'gross_return': gross,
                'gas_cost': gas,
                'net_return': net,
                'net_apy': net / principal
            }
        
        return {
            'optimal_frequency': optimal_frequency,
            'optimal_interval_days': 365 / optimal_frequency,
            'optimal_net_apy': optimal_net_return / principal,
            'comparisons': comparisons,
            'break_even_principal': gas_cost_usd * 365 / apr  # 盈亏平衡本金
        }
    
    @staticmethod
    def calculate_impermanent_loss(
        price_ratio: float,
        pool_type: str = "constant_product"
    ) -> float:
        """
        计算无常损失
        
        Args:
            price_ratio: 价格变化比率 (结束价格/初始价格)
            pool_type: 池类型 (constant_product, stableswap)
            
        Returns:
            il: 无常损失百分比
        """
        if pool_type == "constant_product":
            # Uniswap V2公式
            il = 2 * np.sqrt(price_ratio) / (1 + price_ratio) - 1
        elif pool_type == "stableswap":
            # Curve稳定币池近似公式
            # 对于稳定币，价格偏离较小时IL极低
            deviation = abs(price_ratio - 1)
            il = -0.5 * deviation ** 2 if deviation < 0.1 else None
        
        return il
    
    @staticmethod
    def calculate_leveraged_yield(
        base_apy: float,
        borrow_apy: float,
        leverage: float,
        liquidation_threshold: float = 0.75
    ) -> Dict[str, float]:
        """
        计算杠杆收益策略的收益和风险
        
        Args:
            base_apy: 基础存款收益率
            borrow_apy: 借款利率
            leverage: 杠杆倍数
            liquidation_threshold: 清算阈值
            
        Returns:
            结果字典包含：净APY、清算价格等
        """
        # 净收益 = 存款收益 * 杠杆 - 借款成本 * (杠杆 - 1)
        gross_apy = base_apy * leverage
        borrow_cost = borrow_apy * (leverage - 1)
        net_apy = gross_apy - borrow_cost
        
        # 计算清算风险
        # 假设抵押品价值下跌X%触发清算
        max_drawdown = (1 - liquidation_threshold) / leverage
        
        return {
            'net_apy': net_apy,
            'gross_apy': gross_apy,
            'borrow_cost': borrow_cost,
            'max_safe_drawdown': max_drawdown,
            'liquidation_price_ratio': 1 - max_drawdown
        }

# 示例：比较不同策略
strategies = {
    'Aave USDC': {'apr': 0.03, 'risk': 'low'},
    'Curve 3pool LP': {'apr': 0.05, 'risk': 'medium'},
    'Convex staking': {'apr': 0.12, 'risk': 'medium'},
    'Leveraged farming': {'apr': 0.25, 'risk': 'high'}
}

calculator = YieldCalculator()

print("策略收益对比（考虑日复利）：")
print("-" * 60)
for name, params in strategies.items():
    apy = calculator.calculate_apy(params['apr'], 365)
    print(f"{name:20} | APR: {params['apr']*100:.1f}% | APY: {apy*100:.2f}% | 风险: {params['risk']}")

# 杠杆策略分析
print("\n杠杆策略分析：")
print("-" * 60)
leverages = [1.5, 2.0, 3.0]
for lev in leverages:
    result = calculator.calculate_leveraged_yield(
        base_apy=0.08,  # 8%基础收益
        borrow_apy=0.05,  # 5%借款成本
        leverage=lev
    )
    print(f"杠杆 {lev}x:")
    print(f"  净APY: {result['net_apy']*100:.2f}%")
    print(f"  最大安全回撤: {result['max_safe_drawdown']*100:.1f}%")
    print(f"  清算价格比: {result['liquidation_price_ratio']:.3f}")

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC4626/ERC4626.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

/**
 * @title YieldVault
 * @notice 基于ERC4626的收益金库实现
 * @dev 支持多策略、自动复投、风险管理
 */
contract YieldVault is ERC4626, ReentrancyGuard, AccessControl {
    using SafeERC20 for IERC20;
    
    // 角色定义
    bytes32 public constant STRATEGIST_ROLE = keccak256("STRATEGIST_ROLE");
    bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
    bytes32 public constant KEEPER_ROLE = keccak256("KEEPER_ROLE");
    
    // 策略结构
    struct Strategy {
        address implementation;     // 策略合约地址
        uint256 debtRatio;         // 策略债务比例 (BPS)
        uint256 lastReport;        // 上次报告时间
        uint256 totalDebt;         // 策略总债务
        uint256 totalGain;         // 累计收益
        uint256 totalLoss;         // 累计损失
        uint256 rateLimit;         // 速率限制
        bool active;               // 是否激活
    }
    
    // 状态变量
    mapping(address => Strategy) public strategies;
    address[] public withdrawalQueue;  // 提款队列
    
    uint256 public totalDebtRatio;     // 总债务比例
    uint256 public creditThreshold;    // 信贷阈值
    uint256 public lockedProfit;       // 锁定利润
    uint256 public lastReport;         // 上次报告时间
    uint256 public lockedProfitDegradation; // 利润释放速率
    
    // 费用参数
    uint256 public performanceFee = 1000;  // 10%绩效费
    uint256 public managementFee = 200;    // 2%管理费
    address public feeRecipient;
    
    // 安全参数
    uint256 public emergencyShutdown;
    uint256 public depositLimit;
    
    // 事件
    event StrategyAdded(address indexed strategy, uint256 debtRatio);
    event StrategyReported(
        address indexed strategy,
        uint256 gain,
        uint256 loss,
        uint256 debtPaid,
        uint256 totalDebt
    );
    event EmergencyShutdown(bool active);
    
    constructor(
        IERC20 _asset,
        string memory _name,
        string memory _symbol
    ) ERC4626(_asset) ERC20(_name, _symbol) {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(STRATEGIST_ROLE, msg.sender);
        _setupRole(GUARDIAN_ROLE, msg.sender);
        
        lockedProfitDegradation = 1e18 / 86400; // 24小时线性释放
    }
    
    /**
     * @notice 添加或更新策略
     * @param strategy 策略地址
     * @param debtRatio 债务比例 (BPS, max 10000)
     * @param rateLimit 每个区块的速率限制
     */
    function addStrategy(
        address strategy,
        uint256 debtRatio,
        uint256 rateLimit
    ) external onlyRole(STRATEGIST_ROLE) {
        require(strategy != address(0), "!zero");
        require(totalDebtRatio + debtRatio <= 10000, "!debtRatio");
        
        if (strategies[strategy].implementation == address(0)) {
            // 新策略
            withdrawalQueue.push(strategy);
        }
        
        strategies[strategy] = Strategy({
            implementation: strategy,
            debtRatio: debtRatio,
            lastReport: block.timestamp,
            totalDebt: 0,
            totalGain: 0,
            totalLoss: 0,
            rateLimit: rateLimit,
            active: true
        });
        
        totalDebtRatio += debtRatio;
        emit StrategyAdded(strategy, debtRatio);
    }
    
    /**
     * @notice 策略收割和再平衡
     * @param strategy 要收割的策略
     * @return harvested 收割的收益
     */
    function harvest(address strategy) 
        external 
        onlyRole(KEEPER_ROLE)
        returns (uint256 harvested) 
    {
        Strategy storage strat = strategies[strategy];
        require(strat.active, "!active");
        
        // 计算策略应有的债务
        uint256 targetDebt = totalAssets() * strat.debtRatio / 10000;
        uint256 currentDebt = strat.totalDebt;
        
        // 准备给策略的信贷
        uint256 credit;
        if (targetDebt > currentDebt) {
            credit = Math.min(
                targetDebt - currentDebt,
                asset.balanceOf(address(this))
            );
        }
        
        // 策略报告
        (uint256 gain, uint256 loss, uint256 debtPayment) = 
            IStrategy(strategy).report(credit);
        
        // 更新策略债务
        strat.totalDebt = strat.totalDebt + credit - debtPayment;
        strat.totalGain += gain;
        strat.totalLoss += loss;
        strat.lastReport = block.timestamp;
        
        // 处理收益
        if (gain > 0) {
            // 收取绩效费
            uint256 performanceFeeAmount = gain * performanceFee / 10000;
            if (performanceFeeAmount > 0 && feeRecipient != address(0)) {
                _mint(feeRecipient, convertToShares(performanceFeeAmount));
            }
            
            // 锁定剩余利润，线性释放
            lockedProfit += gain - performanceFeeAmount;
        }
        
        // 处理损失
        if (loss > 0) {
            // 从锁定利润中扣除
            if (lockedProfit >= loss) {
                lockedProfit -= loss;
            } else {
                lockedProfit = 0;
            }
        }
        
        emit StrategyReported(strategy, gain, loss, debtPayment, strat.totalDebt);
        
        return gain;
    }
    
    /**
     * @notice 计算总资产（包括策略中的资产）
     */
    function totalAssets() public view override returns (uint256) {
        uint256 total = asset.balanceOf(address(this));
        
        // 加上所有策略的债务
        for (uint256 i = 0; i < withdrawalQueue.length; i++) {
            Strategy memory strat = strategies[withdrawalQueue[i]];
            if (strat.active) {
                total += strat.totalDebt;
            }
        }
        
        // 减去锁定但未释放的利润
        total -= _calculateLockedProfit();
        
        return total;
    }
    
    /**
     * @notice 计算当前锁定的利润
     */
    function _calculateLockedProfit() internal view returns (uint256) {
        if (lockedProfit == 0) return 0;
        
        uint256 timeSinceLastReport = block.timestamp - lastReport;
        uint256 degradation = lockedProfitDegradation * timeSinceLastReport;
        
        if (degradation >= 1e18) {
            return 0;
        } else {
            return lockedProfit * (1e18 - degradation) / 1e18;
        }
    }
    
    /**
     * @notice 紧急关停
     */
    function setEmergencyShutdown(bool _shutdown) 
        external 
        onlyRole(GUARDIAN_ROLE) 
    {
        emergencyShutdown = _shutdown ? 1 : 0;
        emit EmergencyShutdown(_shutdown);
        
        if (_shutdown) {
            // 召回所有策略资金
            for (uint256 i = 0; i < withdrawalQueue.length; i++) {
                address strategy = withdrawalQueue[i];
                if (strategies[strategy].totalDebt > 0) {
                    IStrategy(strategy).emergencyWithdraw();
                }
            }
        }
    }
    
    /**
     * @notice 提款时的策略资金召回
     */
    function _withdrawFromStrategies(uint256 amount) internal {
        uint256 withdrawn = 0;
        
        // 按照提款队列顺序召回资金
        for (uint256 i = 0; i < withdrawalQueue.length && withdrawn < amount; i++) {
            address strategy = withdrawalQueue[i];
            Strategy storage strat = strategies[strategy];
            
            if (!strat.active || strat.totalDebt == 0) continue;
            
            uint256 toWithdraw = Math.min(amount - withdrawn, strat.totalDebt);
            uint256 actualWithdrawn = IStrategy(strategy).withdraw(toWithdraw);
            
            strat.totalDebt -= actualWithdrawn;
            withdrawn += actualWithdrawn;
        }
        
        require(withdrawn >= amount, "!insufficient");
    }
}

/**
 * @title IStrategy
 * @notice 策略接口
 */
interface IStrategy {
    function report(uint256 credit) external returns (
        uint256 gain,
        uint256 loss,
        uint256 debtPayment
    );
    
    function withdraw(uint256 amount) external returns (uint256);
    
    function emergencyWithdraw() external;
    
    function estimatedTotalAssets() external view returns (uint256);
}

/**
 * @title ConvexStrategy
 * @notice Convex Finance策略示例
 */
contract ConvexStrategy is IStrategy {
    using SafeERC20 for IERC20;
    
    YieldVault public immutable vault;
    IERC20 public immutable want;  // 稳定币
    
    // Convex相关合约
    IConvexBooster public constant booster = IConvexBooster(0xF403C135812408BFbE8713b5A23a04b3D48AAE31);
    IConvexRewards public rewardPool;
    uint256 public pid;  // Convex池ID
    
    // 收益代币
    IERC20 public constant CRV = IERC20(0xD533a949740bb3306d119CC777fa900bA034cd52);
    IERC20 public constant CVX = IERC20(0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B);
    
    modifier onlyVault() {
        require(msg.sender == address(vault), "!vault");
        _;
    }
    
    constructor(
        address _vault,
        uint256 _pid
    ) {
        vault = YieldVault(_vault);
        want = IERC20(vault.asset());
        pid = _pid;
        
        // 获取奖励池地址
        (,,,address _rewardPool,,) = booster.poolInfo(pid);
        rewardPool = IConvexRewards(_rewardPool);
        
        // 授权
        want.safeApprove(address(booster), type(uint256).max);
    }
    
    function estimatedTotalAssets() public view override returns (uint256) {
        return rewardPool.balanceOf(address(this));
    }
    
    function report(uint256 credit) external override onlyVault returns (
        uint256 gain,
        uint256 loss,
        uint256 debtPayment
    ) {
        // 领取奖励
        if (rewardPool.earned(address(this)) > 0) {
            rewardPool.getReward(address(this), true);
        }
        
        // 卖出奖励代币
        uint256 crvBalance = CRV.balanceOf(address(this));
        uint256 cvxBalance = CVX.balanceOf(address(this));
        
        if (crvBalance > 0) {
            _sellCRV(crvBalance);
        }
        if (cvxBalance > 0) {
            _sellCVX(cvxBalance);
        }
        
        // 计算收益
        uint256 totalAssets = estimatedTotalAssets();
        uint256 debt = vault.strategies(address(this)).totalDebt;
        
        if (totalAssets > debt) {
            gain = totalAssets - debt;
        } else if (totalAssets < debt) {
            loss = debt - totalAssets;
        }
        
        // 处理credit（新增投资）
        if (credit > 0) {
            want.safeTransferFrom(address(vault), address(this), credit);
            _deposit(credit);
        }
        
        // 返还多余资金
        uint256 wantBalance = want.balanceOf(address(this));
        if (wantBalance > 0) {
            want.safeTransfer(address(vault), wantBalance);
            debtPayment = wantBalance;
        }
    }
    
    function withdraw(uint256 amount) external override onlyVault returns (uint256) {
        uint256 balance = want.balanceOf(address(this));
        
        if (balance < amount) {
            uint256 toWithdraw = amount - balance;
            rewardPool.withdrawAndUnwrap(toWithdraw, false);
        }
        
        uint256 withdrawn = Math.min(amount, want.balanceOf(address(this)));
        want.safeTransfer(address(vault), withdrawn);
        
        return withdrawn;
    }
    
    function emergencyWithdraw() external override onlyVault {
        rewardPool.withdrawAndUnwrap(rewardPool.balanceOf(address(this)), false);
        want.safeTransfer(address(vault), want.balanceOf(address(this)));
    }
    
    function _deposit(uint256 amount) internal {
        booster.deposit(pid, amount, true);
    }
    
    function _sellCRV(uint256 amount) internal {
        // 通过Curve或Uniswap卖出CRV换取want代币
        // 实现略...
    }
    
    function _sellCVX(uint256 amount) internal {
        // 通过DEX卖出CVX换取want代币
        // 实现略...
    }
}

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

import "@layerzerolabs/contracts/interfaces/ILayerZeroEndpoint.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

/**
 * @title CrossChainYieldRouter
 * @notice 跨链收益优化路由器
 * @dev 自动寻找最优收益机会并跨链部署资金
 */
contract CrossChainYieldRouter is Pausable {
    using SafeERC20 for IERC20;
    
    struct ChainInfo {
        uint16 chainId;           // LayerZero链ID
        address yieldVault;       // 该链上的收益金库
        uint256 currentAPY;       // 当前APY（BPS）
        uint256 tvlCap;          // TVL上限
        uint256 currentTVL;      // 当前TVL
        bool active;             // 是否激活
    }
    
    struct PendingRebalance {
        uint16 fromChain;
        uint16 toChain;
        uint256 amount;
        uint256 timestamp;
        bytes32 txHash;
    }
    
    // LayerZero端点
    ILayerZeroEndpoint public immutable lzEndpoint;
    
    // 链信息映射
    mapping(uint16 => ChainInfo) public chains;
    uint16[] public supportedChains;
    
    // 跨链消息类型
    uint8 constant MSG_DEPOSIT = 1;
    uint8 constant MSG_WITHDRAW = 2;
    uint8 constant MSG_REBALANCE = 3;
    uint8 constant MSG_UPDATE_APY = 4;
    
    // 再平衡参数
    uint256 public rebalanceThreshold = 200; // 2% APY差异触发再平衡
    uint256 public minRebalanceAmount = 10000e6; // 最小再平衡金额 $10k
    uint256 public rebalanceCooldown = 3600; // 1小时冷却期
    mapping(bytes32 => uint256) public lastRebalance;
    
    // 待处理的再平衡
    mapping(bytes32 => PendingRebalance) public pendingRebalances;
    
    // Gas费用估算
    mapping(uint16 => uint256) public gasEstimates;
    
    event ChainAdded(uint16 indexed chainId, address yieldVault);
    event RebalanceInitiated(
        uint16 indexed fromChain,
        uint16 indexed toChain,
        uint256 amount,
        uint256 apyDiff
    );
    event RebalanceCompleted(bytes32 indexed rebalanceId);
    event APYUpdated(uint16 indexed chainId, uint256 newAPY);
    
    constructor(address _lzEndpoint) {
        lzEndpoint = ILayerZeroEndpoint(_lzEndpoint);
    }
    
    /**
     * @notice 计算最优收益分配
     * @return allocations 每条链的最优分配比例
     */
    function calculateOptimalAllocation() 
        public 
        view 
        returns (uint256[] memory allocations) 
    {
        uint256 totalTVL = 0;
        uint256[] memory availableSpace = new uint256[](supportedChains.length);
        uint256[] memory apys = new uint256[](supportedChains.length);
        
        // 收集链信息
        for (uint256 i = 0; i < supportedChains.length; i++) {
            ChainInfo memory chain = chains[supportedChains[i]];
            if (chain.active) {
                availableSpace[i] = chain.tvlCap > chain.currentTVL ? 
                    chain.tvlCap - chain.currentTVL : 0;
                apys[i] = chain.currentAPY;
                totalTVL += chain.currentTVL;
            }
        }
        
        allocations = new uint256[](supportedChains.length);
        
        // 贪心算法：优先填充高APY的链
        uint256 remainingTVL = totalTVL;
        while (remainingTVL > 0) {
            uint256 bestChain = type(uint256).max;
            uint256 bestAPY = 0;
            
            // 找到最高APY且有空间的链
            for (uint256 i = 0; i < supportedChains.length; i++) {
                if (availableSpace[i] > 0 && apys[i] > bestAPY) {
                    bestAPY = apys[i];
                    bestChain = i;
                }
            }
            
            if (bestChain == type(uint256).max) break;
            
            // 分配资金
            uint256 toAllocate = Math.min(availableSpace[bestChain], remainingTVL);
            allocations[bestChain] += toAllocate;
            availableSpace[bestChain] -= toAllocate;
            remainingTVL -= toAllocate;
        }
        
        return allocations;
    }
    
    /**
     * @notice 检查并执行再平衡
     * @param maxGasPrice 最大可接受的gas价格
     */
    function checkAndRebalance(uint256 maxGasPrice) external {
        require(tx.gasprice <= maxGasPrice, "Gas price too high");
        
        uint256[] memory optimalAllocations = calculateOptimalAllocation();
        
        for (uint256 i = 0; i < supportedChains.length; i++) {
            uint16 fromChain = supportedChains[i];
            ChainInfo memory fromInfo = chains[fromChain];
            
            if (!fromInfo.active) continue;
            
            // 计算需要移出的金额
            uint256 currentAllocation = fromInfo.currentTVL;
            uint256 targetAllocation = optimalAllocations[i];
            
            if (currentAllocation > targetAllocation + minRebalanceAmount) {
                // 需要移出资金
                uint256 toMove = currentAllocation - targetAllocation;
                
                // 找到最佳目标链
                uint16 bestTarget = _findBestTargetChain(toMove, fromChain);
                
                if (bestTarget != 0) {
                    _initiateRebalance(fromChain, bestTarget, toMove);
                }
            }
        }
    }
    
    /**
     * @notice 发起跨链再平衡
     */
    function _initiateRebalance(
        uint16 fromChain,
        uint16 toChain,
        uint256 amount
    ) internal {
        // 检查冷却期
        bytes32 pairKey = keccak256(abi.encodePacked(fromChain, toChain));
        require(
            block.timestamp >= lastRebalance[pairKey] + rebalanceCooldown,
            "Rebalance cooldown"
        );
        
        // 计算跨链成本
        uint256 estimatedCost = _estimateCrossChainCost(fromChain, toChain, amount);
        uint256 apyDiff = chains[toChain].currentAPY - chains[fromChain].currentAPY;
        uint256 expectedGain = amount * apyDiff / 10000 / 365; // 日收益差
        
        require(expectedGain > estimatedCost * 10, "Rebalance not profitable");
        
        // 构建跨链消息
        bytes memory payload = abi.encode(
            MSG_REBALANCE,
            fromChain,
            toChain,
            amount,
            block.timestamp
        );
        
        // 发送跨链消息
        _lzSend(
            fromChain,
            payload,
            payable(msg.sender),
            address(0),
            bytes(""),
            msg.value
        );
        
        // 记录待处理的再平衡
        bytes32 rebalanceId = keccak256(payload);
        pendingRebalances[rebalanceId] = PendingRebalance({
            fromChain: fromChain,
            toChain: toChain,
            amount: amount,
            timestamp: block.timestamp,
            txHash: rebalanceId
        });
        
        lastRebalance[pairKey] = block.timestamp;
        
        emit RebalanceInitiated(fromChain, toChain, amount, apyDiff);
    }
    
    /**
     * @notice LayerZero接收函数
     */
    function lzReceive(
        uint16 _srcChainId,
        bytes calldata _srcAddress,
        uint64 _nonce,
        bytes calldata _payload
    ) external {
        require(msg.sender == address(lzEndpoint), "Invalid endpoint");
        
        uint8 msgType = uint8(bytes1(_payload[0:1]));
        
        if (msgType == MSG_UPDATE_APY) {
            _handleAPYUpdate(_srcChainId, _payload);
        } else if (msgType == MSG_REBALANCE) {
            _handleRebalance(_srcChainId, _payload);
        }
    }
    
    /**
     * @notice 处理APY更新
     */
    function _handleAPYUpdate(uint16 chainId, bytes calldata payload) internal {
        (, uint256 newAPY, uint256 newTVL) = abi.decode(
            payload,
            (uint8, uint256, uint256)
        );
        
        chains[chainId].currentAPY = newAPY;
        chains[chainId].currentTVL = newTVL;
        
        emit APYUpdated(chainId, newAPY);
    }
    
    /**
     * @notice 估算跨链成本
     */
    function _estimateCrossChainCost(
        uint16 fromChain,
        uint16 toChain,
        uint256 amount
    ) internal view returns (uint256) {
        // LayerZero费用
        uint256 lzFee = gasEstimates[toChain] * tx.gasprice;
        
        // 桥接费用（通常是0.1%）
        uint256 bridgeFee = amount * 10 / 10000;
        
        // 目标链执行费用
        uint256 executionFee = gasEstimates[toChain] * 1e9; // 假设10 Gwei
        
        return lzFee + bridgeFee + executionFee;
    }
}

import numpy as np
import pandas as pd
from typing import Dict, Tuple
from dataclasses import dataclass
import ccxt  # 交易所API
import asyncio

@dataclass
class Position:
    """持仓信息"""
    asset: str
    amount: float
    entry_price: float
    current_price: float
    venue: str  # 'spot' or 'perp'
    
    @property
    def value(self) -> float:
        return self.amount * self.current_price
    
    @property
    def pnl(self) -> float:
        return (self.current_price - self.entry_price) * self.amount

class DeltaNeutralManager:
    """Delta中性策略管理器"""
    
    def __init__(self, spot_venue: str, perp_venue: str):
        self.spot_venue = spot_venue
        self.perp_venue = perp_venue
        self.target_delta = 0.0
        self.rebalance_threshold = 0.05  # 5% delta偏离触发再平衡
        
    def calculate_portfolio_delta(self, positions: List[Position]) -> float:
        """计算组合的总Delta敞口"""
        total_delta = 0.0
        
        for pos in positions:
            if pos.venue == 'spot':
                # 现货多头delta = +1
                total_delta += pos.amount
            elif pos.venue == 'perp':
                # 永续空头delta = -1
                total_delta += pos.amount  # amount为负表示空头
                
        return total_delta
    
    def calculate_funding_pnl(self, 
                            funding_rate: float,
                            position_size: float,
                            hours: int = 8) -> float:
        """计算资金费率收益"""
        # 大多数交易所8小时结算一次
        periods = hours / 8
        return position_size * funding_rate * periods
    
    def check_rebalance_needed(self, positions: List[Position]) -> Tuple[bool, float]:
        """检查是否需要再平衡"""
        current_delta = self.calculate_portfolio_delta(positions)
        delta_ratio = abs(current_delta) / sum(abs(p.amount) for p in positions)
        
        needs_rebalance = delta_ratio > self.rebalance_threshold
        return needs_rebalance, current_delta
    
    def calculate_rebalance_trades(self, 
                                 current_delta: float,
                                 spot_price: float,
                                 perp_price: float) -> Dict[str, float]:
        """计算再平衡所需的交易"""
        # 计算需要调整的数量
        adjustment = -current_delta / 2  # 平分到现货和永续
        
        return {
            'spot_adjustment': adjustment,
            'perp_adjustment': -adjustment,
            'estimated_cost': abs(adjustment) * 0.001 * spot_price  # 0.1%滑点估计
        }
    
    def monitor_lst_basis(self, lst_price: float, eth_price: float) -> Dict[str, float]:
        """监控LST基差（用于LSTfi策略）"""
        basis = lst_price / eth_price - 1
        annualized_basis = basis * 365 / 7  # 假设7天平均回归
        
        return {
            'current_basis': basis,
            'annualized_return': annualized_basis,
            'deviation_warning': abs(basis) > 0.02,  # 2%偏离警告
            'suggested_action': 'increase' if basis > 0.01 else 'reduce' if basis < -0.01 else 'hold'
        }

# 使用示例
async def run_delta_neutral_strategy():
    manager = DeltaNeutralManager('aave', 'gmx')
    
    # 模拟持仓
    positions = [
        Position('ETH', 10, 2000, 2100, 'spot'),      # 现货多头
        Position('ETH', -10, 2000, 2100, 'perp'),     # 永续空头
        Position('stETH', 5, 1995, 2095, 'spot'),     # LST持仓
    ]
    
    # 检查再平衡
    needs_rebalance, current_delta = manager.check_rebalance_needed(positions)
    
    if needs_rebalance:
        trades = manager.calculate_rebalance_trades(current_delta, 2100, 2100)
        print(f"需要再平衡: Delta = {current_delta:.4f}")
        print(f"建议交易: {trades}")
    
    # 监控LST基差
    lst_monitor = manager.monitor_lst_basis(2095, 2100)
    print(f"stETH/ETH基差: {lst_monitor['current_basis']:.4%}")
    print(f"年化收益: {lst_monitor['annualized_return']:.2%}")

# 运行示例
# asyncio.run(run_delta_neutral_strategy())

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

class RiskType(Enum):
    SMART_CONTRACT = "智能合约风险"
    LIQUIDITY = "流动性风险"
    ORACLE = "预言机风险"
    GOVERNANCE = "治理风险"
    ECONOMIC = "经济模型风险"
    OPERATIONAL = "操作风险"

@dataclass
class RiskFactor:
    """风险因子"""
    type: RiskType
    severity: float  # 0-1
    probability: float  # 0-1
    mitigation: str
    
    @property
    def score(self) -> float:
        """风险分数 = 严重性 × 概率"""
        return self.severity * self.probability

class YieldStrategyRiskAssessment:
    """收益策略风险评估框架"""
    
    def __init__(self):
        self.risk_weights = {
            RiskType.SMART_CONTRACT: 0.3,
            RiskType.LIQUIDITY: 0.2,
            RiskType.ORACLE: 0.2,
            RiskType.GOVERNANCE: 0.1,
            RiskType.ECONOMIC: 0.15,
            RiskType.OPERATIONAL: 0.05
        }
    
    def calculate_var_cvar(self, returns: np.ndarray, confidence: float = 0.95) -> Dict[str, float]:
        """
        计算VaR（风险价值）和CVaR（条件风险价值）
        
        Args:
            returns: 历史收益率数组
            confidence: 置信水平
            
        Returns:
            VaR和CVaR值
        """
        # 计算VaR
        var_percentile = (1 - confidence) * 100
        var = np.percentile(returns, var_percentile)
        
        # 计算CVaR（超过VaR的平均损失）
        cvar = returns[returns <= var].mean()
        
        return {
            'var': abs(var),
            'cvar': abs(cvar),
            'var_percentile': var_percentile,
            'worst_case': returns.min(),
            'risk_ratio': abs(cvar / var) if var != 0 else np.inf
        }
    
    def simulate_impermanent_loss(self, 
                                price_range: Tuple[float, float],
                                steps: int = 100) -> pd.DataFrame:
        """
        模拟不同价格变化下的无常损失
        
        Args:
            price_range: 价格变化范围（如(0.5, 2.0)表示-50%到+100%）
            steps: 模拟步数
            
        Returns:
            包含价格比率和IL的DataFrame
        """
        price_ratios = np.linspace(price_range[0], price_range[1], steps)
        
        # 计算不同AMM的IL
        il_data = {
            'price_ratio': price_ratios,
            'uniswap_v2': [self._calculate_il_v2(r) for r in price_ratios],
            'stable_swap': [self._calculate_il_stable(r) for r in price_ratios],
            'uniswap_v3_narrow': [self._calculate_il_v3(r, 0.99, 1.01) for r in price_ratios],
            'uniswap_v3_wide': [self._calculate_il_v3(r, 0.95, 1.05) for r in price_ratios]
        }
        
        return pd.DataFrame(il_data)
    
    def _calculate_il_v2(self, price_ratio: float) -> float:
        """Uniswap V2无常损失公式"""
        return 2 * np.sqrt(price_ratio) / (1 + price_ratio) - 1
    
    def _calculate_il_stable(self, price_ratio: float) -> float:
        """稳定币池近似无常损失"""
        deviation = abs(price_ratio - 1)
        if deviation < 0.1:  # 10%以内使用二次近似
            return -0.5 * deviation ** 2
        else:
            # 超过10%使用标准公式
            return self._calculate_il_v2(price_ratio)
    
    def _calculate_il_v3(self, price_ratio: float, 
                        lower_bound: float, upper_bound: float) -> float:
        """Uniswap V3集中流动性IL（简化）"""
        if lower_bound <= price_ratio <= upper_bound:
            # 在范围内，IL接近V2
            return self._calculate_il_v2(price_ratio)
        else:
            # 超出范围，全部转换为单一资产
            return -1.0 if price_ratio < lower_bound else -0.5
    
    def assess_depeg_risk(self, 
                         stablecoin: str,
                         collateral_ratio: float,
                         liquidity_depth: float,
                         concentration: float) -> Dict[str, float]:
        """
        评估稳定币脱锚风险
        
        Args:
            stablecoin: 稳定币名称
            collateral_ratio: 抵押率
            liquidity_depth: 流动性深度（USD）
            concentration: 持仓集中度（前10地址占比）
            
        Returns:
            脱锚风险评分
        """
        # 基础风险分数
        base_score = 0.0
        
        # 抵押率评分（越高越安全）
        if collateral_ratio < 1.0:
            base_score += 50  # 部分储备高风险
        elif collateral_ratio < 1.5:
            base_score += 20  # 略微超额抵押
        else:
            base_score += 5   # 充分超额抵押
            
        # 流动性评分（越深越安全）
        if liquidity_depth < 10e6:  # <$10M
            base_score += 30
        elif liquidity_depth < 100e6:  # <$100M
            base_score += 15
        else:
            base_score += 5
            
        # 集中度评分（越分散越安全）
        if concentration > 0.5:  # >50%
            base_score += 20
        elif concentration > 0.3:  # >30%
            base_score += 10
        else:
            base_score += 5
            
        # 特定稳定币调整
        stablecoin_factors = {
            'USDT': 1.2,    # 历史不透明
            'USDC': 0.8,    # 监管合规
            'DAI': 1.0,     # 去中心化
            'FRAX': 1.3,    # 部分算法
            'LUSD': 0.9     # 超额抵押
        }
        
        factor = stablecoin_factors.get(stablecoin.upper(), 1.0)
        final_score = base_score * factor
        
        return {
            'depeg_risk_score': final_score,
            'risk_level': self._score_to_level(final_score),
            'collateral_contribution': base_score * 0.5,
            'liquidity_contribution': base_score * 0.3,
            'concentration_contribution': base_score * 0.2,
            'recommendation': self._get_depeg_recommendation(final_score)
        }
    
    def _score_to_level(self, score: float) -> str:
        """将分数转换为风险等级"""
        if score < 20:
            return "低风险"
        elif score < 40:
            return "中低风险"
        elif score < 60:
            return "中风险"
        elif score < 80:
            return "高风险"
        else:
            return "极高风险"
    
    def _get_depeg_recommendation(self, score: float) -> str:
        """基于风险分数的建议"""
        if score < 20:
            return "适合作为主要储备资产"
        elif score < 40:
            return "可以持有，建议分散配置"
        elif score < 60:
            return "谨慎持有，设置止损"
        else:
            return "不建议持有，寻找替代品"
    
    def assess_strategy_risk(
        self,
        protocol_name: str,
        tvl: float,
        age_days: int,
        audit_score: float,
        complexity_score: float
    ) -> Dict:
        """
        评估策略整体风险
        
        Args:
            protocol_name: 协议名称
            tvl: 总锁仓价值（USD）
            age_days: 协议运行天数
            audit_score: 审计分数（0-10）
            complexity_score: 复杂度分数（0-10）
        """
        risk_factors = []
        
        # 智能合约风险评估
        contract_risk_score = self._assess_smart_contract_risk(
            age_days, audit_score, complexity_score
        )
        risk_factors.append(RiskFactor(
            type=RiskType.SMART_CONTRACT,
            severity=0.9,  # 合约风险通常很严重
            probability=contract_risk_score,
            mitigation="多重审计、形式化验证、保险覆盖"
        ))
        
        # 流动性风险评估
        liquidity_risk_score = self._assess_liquidity_risk(tvl)
        risk_factors.append(RiskFactor(
            type=RiskType.LIQUIDITY,
            severity=0.7,
            probability=liquidity_risk_score,
            mitigation="分散投资、设置提款限制、维持缓冲资金"
        ))
        
        # 预言机风险评估
        oracle_risk_score = self._assess_oracle_risk(protocol_name)
        risk_factors.append(RiskFactor(
            type=RiskType.ORACLE,
            severity=0.8,
            probability=oracle_risk_score,
            mitigation="多预言机聚合、TWAP、熔断机制"
        ))
        
        # 计算综合风险分数
        total_risk_score = self._calculate_total_risk(risk_factors)
        
        # 风险等级判定
        risk_level = self._determine_risk_level(total_risk_score)
        
        # 建议配置比例
        suggested_allocation = self._suggest_allocation(total_risk_score)
        
        return {
            'protocol': protocol_name,
            'risk_factors': risk_factors,
            'total_risk_score': total_risk_score,
            'risk_level': risk_level,
            'suggested_allocation': suggested_allocation,
            'risk_adjusted_apy': self._calculate_risk_adjusted_return(
                base_apy=0.15,  # 假设15%基础APY
                risk_score=total_risk_score
            )
        }
    
    def _assess_smart_contract_risk(
        self,
        age_days: int,
        audit_score: float,
        complexity_score: float
    ) -> float:
        """评估智能合约风险概率"""
        # 基础风险
        base_risk = 0.3
        
        # 根据运行时间调整（Lindy效应）
        if age_days < 30:
            time_factor = 2.0
        elif age_days < 180:
            time_factor = 1.5
        elif age_days < 365:
            time_factor = 1.2
        else:
            time_factor = 0.8
        
        # 根据审计分数调整
        audit_factor = (10 - audit_score) / 10
        
        # 根据复杂度调整
        complexity_factor = complexity_score / 10
        
        risk_probability = base_risk * time_factor * audit_factor * (1 + complexity_factor)
        
        return min(risk_probability, 1.0)
    
    def _assess_liquidity_risk(self, tvl: float) -> float:
        """评估流动性风险"""
        # TVL越低，流动性风险越高
        if tvl < 1e6:  # < $1M
            return 0.8
        elif tvl < 10e6:  # < $10M
            return 0.5
        elif tvl < 100e6:  # < $100M
            return 0.3
        elif tvl < 1e9:  # < $1B
            return 0.1
        else:
            return 0.05
    
    def _assess_oracle_risk(self, protocol_name: str) -> float:
        """评估预言机风险"""
        # 简化示例：根据协议使用的预言机类型
        chainlink_protocols = ['aave', 'compound', 'maker']
        internal_oracle_protocols = ['curve', 'uniswap']
        
        if protocol_name.lower() in chainlink_protocols:
            return 0.1  # Chainlink相对安全
        elif protocol_name.lower() in internal_oracle_protocols:
            return 0.3  # 内部预言机风险较高
        else:
            return 0.5  # 未知预言机风险
    
    def _calculate_total_risk(self, risk_factors: List[RiskFactor]) -> float:
        """计算加权总风险分数"""
        total_score = 0
        
        for factor in risk_factors:
            weight = self.risk_weights.get(factor.type, 0.1)
            total_score += factor.score * weight
        
        return total_score
    
    def _determine_risk_level(self, risk_score: float) -> str:
        """确定风险等级"""
        if risk_score < 0.2:
            return "低风险"
        elif risk_score < 0.4:
            return "中低风险"
        elif risk_score < 0.6:
            return "中风险"
        elif risk_score < 0.8:
            return "高风险"
        else:
            return "极高风险"
    
    def _suggest_allocation(self, risk_score: float) -> float:
        """建议配置比例"""
        # 反向关系：风险越高，建议配置越低
        if risk_score < 0.2:
            return 0.4  # 最多40%
        elif risk_score < 0.4:
            return 0.25
        elif risk_score < 0.6:
            return 0.15
        elif risk_score < 0.8:
            return 0.05
        else:
            return 0  # 不建议配置
    
    def _calculate_risk_adjusted_return(
        self,
        base_apy: float,
        risk_score: float
    ) -> float:
        """计算风险调整后收益率（类似夏普比率）"""
        # 假设无风险利率为2%
        risk_free_rate = 0.02
        
        # 风险调整
        # 风险越高，要求的风险溢价越高
        risk_premium = (base_apy - risk_free_rate) * (1 - risk_score)
        
        return risk_free_rate + risk_premium

# 示例：评估不同协议
assessor = YieldStrategyRiskAssessment()

protocols = [
    {
        'name': 'Aave',
        'tvl': 5e9,
        'age_days': 1000,
        'audit_score': 9,
        'complexity_score': 6
    },
    {
        'name': 'NewDeFi',
        'tvl': 5e6,
        'age_days': 30,
        'audit_score': 7,
        'complexity_score': 8
    },
    {
        'name': 'CurveFinance',
        'tvl': 3e9,
        'age_days': 800,
        'audit_score': 8.5,
        'complexity_score': 9
    }
]

print("收益策略风险评估报告")
print("=" * 80)

for protocol in protocols:
    result = assessor.assess_strategy_risk(**protocol)
    
    print(f"\n协议: {result['protocol']}")
    print(f"风险等级: {result['risk_level']}")
    print(f"总风险分数: {result['total_risk_score']:.3f}")
    print(f"建议配置比例: {result['suggested_allocation']*100:.1f}%")
    print(f"风险调整后APY: {result['risk_adjusted_apy']*100:.2f}%")
    
    print("\n风险因子明细:")
    for factor in result['risk_factors']:
        print(f"  - {factor.type.value}: 分数={factor.score:.3f}, "
              f"严重性={factor.severity:.1f}, 概率={factor.probability:.2f}")
        print(f"    缓解措施: {factor.mitigation}")

# 组合风险分析
print("\n" + "="*80)
print("组合配置建议：")

total_allocation = sum(result['suggested_allocation'] for result in 
                      [assessor.assess_strategy_risk(**p) for p in protocols])

for protocol in protocols:
    result = assessor.assess_strategy_risk(**protocol)
    normalized_allocation = result['suggested_allocation'] / total_allocation
    print(f"{protocol['name']:15} {normalized_allocation*100:>6.1f}%")

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

/**
 * @title YieldMonitor
 * @notice 实时监控收益策略健康度
 */
contract YieldMonitor {
    using SafeMath for uint256;
    
    struct StrategyHealth {
        uint256 targetAPY;        // 目标APY
        uint256 actualAPY;        // 实际APY
        uint256 tvl;              // 总锁仓价值
        uint256 utilizationRate;  // 资金利用率
        uint256 lastUpdate;       // 最后更新时间
        bool isHealthy;           // 健康状态
        uint256 riskScore;        // 风险分数(0-10000)
    }
    
    struct Alert {
        uint256 timestamp;
        AlertType alertType;
        address strategy;
        string message;
        uint256 severity;  // 1-5
    }
    
    enum AlertType {
        APY_DEVIATION,      // APY偏离
        TVL_DRAIN,          // TVL快速下降
        UTILIZATION_LOW,    // 利用率过低
        RISK_INCREASE,      // 风险上升
        CONTRACT_PAUSED,    // 合约暂停
        ORACLE_FAILURE      // 预言机故障
    }
    
    mapping(address => StrategyHealth) public strategies;
    Alert[] public alerts;
    
    // 阈值参数
    uint256 public apyDeviationThreshold = 2000;  // 20%偏离触发警报
    uint256 public tvlDrainThreshold = 1000;      // 10%快速流失触发警报
    uint256 public minUtilizationRate = 5000;     // 50%最低利用率
    uint256 public maxRiskScore = 7000;           // 70风险分数上限
    
    // 监控参数
    mapping(address => uint256) public lastTVL;
    mapping(address => uint256) public tvlCheckpoint;
    
    event HealthUpdate(address indexed strategy, bool isHealthy, uint256 riskScore);
    event AlertRaised(address indexed strategy, AlertType alertType, uint256 severity);
    
    /**
     * @notice 更新策略健康状态
     */
    function updateStrategyHealth(
        address strategy,
        uint256 actualAPY,
        uint256 tvl,
        uint256 utilizationRate
    ) external {
        StrategyHealth storage health = strategies[strategy];
        
        // 检查APY偏离
        if (health.targetAPY > 0) {
            uint256 deviation = _calculateDeviation(actualAPY, health.targetAPY);
            if (deviation > apyDeviationThreshold) {
                _raiseAlert(
                    strategy,
                    AlertType.APY_DEVIATION,
                    "APY deviation exceeds threshold",
                    3
                );
            }
        }
        
        // 检查TVL流失
        if (lastTVL[strategy] > 0) {
            uint256 tvlChange = _calculateChange(tvl, lastTVL[strategy]);
            if (tvlChange > tvlDrainThreshold) {
                _raiseAlert(
                    strategy,
                    AlertType.TVL_DRAIN,
                    "Rapid TVL decrease detected",
                    4
                );
            }
        }
        
        // 检查利用率
        if (utilizationRate < minUtilizationRate) {
            _raiseAlert(
                strategy,
                AlertType.UTILIZATION_LOW,
                "Low utilization rate",
                2
            );
        }
        
        // 计算风险分数
        uint256 riskScore = _calculateRiskScore(
            actualAPY,
            tvl,
            utilizationRate,
            deviation
        );
        
        // 更新健康状态
        health.actualAPY = actualAPY;
        health.tvl = tvl;
        health.utilizationRate = utilizationRate;
        health.lastUpdate = block.timestamp;
        health.riskScore = riskScore;
        health.isHealthy = riskScore < maxRiskScore;
        
        lastTVL[strategy] = tvl;
        
        emit HealthUpdate(strategy, health.isHealthy, riskScore);
    }
    
    /**
     * @notice 计算风险分数
     */
    function _calculateRiskScore(
        uint256 actualAPY,
        uint256 tvl,
        uint256 utilizationRate,
        uint256 apyDeviation
    ) internal pure returns (uint256) {
        uint256 score = 0;
        
        // APY偏离贡献（权重40%）
        score = score.add(apyDeviation.mul(40).div(100));
        
        // 低TVL贡献（权重30%）
        if (tvl < 1e6 * 1e6) {  // < $1M
            score = score.add(3000);
        } else if (tvl < 10e6 * 1e6) {  // < $10M
            score = score.add(1500);
        }
        
        // 低利用率贡献（权重20%）
        if (utilizationRate < 5000) {
            score = score.add(2000);
        }
        
        // 高APY风险（权重10%）
        if (actualAPY > 5000) {  // > 50% APY
            score = score.add(1000);
        }
        
        return Math.min(score, 10000);
    }
    
    /**
     * @notice 批量健康检查
     */
    function batchHealthCheck(address[] calldata _strategies) external view 
        returns (bool[] memory isHealthy, uint256[] memory riskScores) 
    {
        isHealthy = new bool[](_strategies.length);
        riskScores = new uint256[](_strategies.length);
        
        for (uint256 i = 0; i < _strategies.length; i++) {
            StrategyHealth memory health = strategies[_strategies[i]];
            isHealthy[i] = health.isHealthy;
            riskScores[i] = health.riskScore;
        }
    }
    
    /**
     * @notice 获取最近的警报
     */
    function getRecentAlerts(uint256 count) external view 
        returns (Alert[] memory) 
    {
        uint256 length = alerts.length;
        if (count > length) count = length;
        
        Alert[] memory recentAlerts = new Alert[](count);
        for (uint256 i = 0; i < count; i++) {
            recentAlerts[i] = alerts[length - 1 - i];
        }
        
        return recentAlerts;
    }
}

import torch
import torch.nn as nn
import numpy as np
from typing import Dict, List, Tuple
import pandas as pd

class YieldPredictionLSTM(nn.Module):
    """LSTM模型用于收益率预测"""
    
    def __init__(self, input_size: int, hidden_size: int = 128, num_layers: int = 2):
        super(YieldPredictionLSTM, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, 1)
        self.dropout = nn.Dropout(0.2)
        
    def forward(self, x):
        # LSTM层
        lstm_out, _ = self.lstm(x)
        
        # 取最后一个时间步的输出
        last_output = lstm_out[:, -1, :]
        
        # 全连接层
        output = self.fc(self.dropout(last_output))
        return output

class AIYieldOptimizer:
    """AI驱动的收益优化器"""
    
    def __init__(self, lookback_window: int = 24):
        self.lookback_window = lookback_window
        self.model = YieldPredictionLSTM(input_size=10)  # 10个特征
        self.scaler = None
        
    def prepare_features(self, protocol_data: pd.DataFrame) -> np.ndarray:
        """
        准备模型输入特征
        
        Features:
        - TVL变化率
        - 利用率
        - 历史APY
        - Gas价格
        - 市场波动率
        - 交易量
        - 持仓集中度
        - 协议年龄
        - 审计分数
        - 社交媒体情绪
        """
        features = []
        
        # TVL变化率
        features.append(protocol_data['tvl'].pct_change().fillna(0))
        
        # 利用率
        features.append(protocol_data['utilization_rate'])
        
        # 历史APY（移动平均）
        features.append(protocol_data['apy'].rolling(window=7).mean())
        
        # Gas价格（标准化）
        features.append(protocol_data['gas_price'] / 100)
        
        # 市场波动率（使用收益率标准差）
        features.append(protocol_data['apy'].rolling(window=7).std())
        
        # 其他特征...
        
        return np.column_stack(features)
    
    def predict_optimal_allocation(self, 
                                 protocols: List[str],
                                 historical_data: Dict[str, pd.DataFrame],
                                 risk_tolerance: float = 0.5) -> Dict[str, float]:
        """
        预测最优资金分配
        
        Args:
            protocols: 协议列表
            historical_data: 历史数据
            risk_tolerance: 风险容忍度(0-1)
            
        Returns:
            各协议的最优配置比例
        """
        predictions = {}
        risk_scores = {}
        
        # 为每个协议预测未来收益
        for protocol in protocols:
            data = historical_data[protocol]
            features = self.prepare_features(data)
            
            # 预测未来24小时APY
            with torch.no_grad():
                future_apy = self.model(torch.FloatTensor(features[-self.lookback_window:]))
                predictions[protocol] = future_apy.item()
            
            # 计算风险分数
            risk_scores[protocol] = self._calculate_risk_score(data)
        
        # 优化配置（考虑风险调整后收益）
        allocations = self._optimize_allocation(
            predictions, 
            risk_scores, 
            risk_tolerance
        )
        
        return allocations
    
    def _calculate_risk_score(self, data: pd.DataFrame) -> float:
        """计算协议风险分数"""
        # 基于历史数据的多维度风险评估
        volatility = data['apy'].std()
        max_drawdown = (data['tvl'].max() - data['tvl'].min()) / data['tvl'].max()
        
        risk_score = 0.6 * volatility + 0.4 * max_drawdown
        return min(risk_score, 1.0)
    
    def _optimize_allocation(self, 
                           predictions: Dict[str, float],
                           risk_scores: Dict[str, float],
                           risk_tolerance: float) -> Dict[str, float]:
        """
        基于预测和风险的配置优化
        使用简化的马科维茨组合理论
        """
        # 计算风险调整后收益
        risk_adjusted_returns = {}
        for protocol, pred_apy in predictions.items():
            risk = risk_scores[protocol]
            # Sharpe-like ratio
            risk_adjusted_returns[protocol] = pred_apy / (1 + risk * (1 - risk_tolerance))
        
        # 归一化为配置比例
        total = sum(risk_adjusted_returns.values())
        allocations = {
            protocol: value / total 
            for protocol, value in risk_adjusted_returns.items()
        }
        
        return allocations

# 实时异常检测
class AnomalyDetector:
    """基于自编码器的异常检测"""
    
    def __init__(self, input_dim: int):
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 16)
        )
        
        self.decoder = nn.Sequential(
            nn.Linear(16, 32),
            nn.ReLU(),
            nn.Linear(32, 64),
            nn.ReLU(),
            nn.Linear(64, input_dim)
        )
        
        self.threshold = None
        
    def detect_anomaly(self, data: torch.Tensor) -> Tuple[bool, float]:
        """检测是否存在异常"""
        # 编码-解码
        encoded = self.encoder(data)
        decoded = self.decoder(encoded)
        
        # 计算重建误差
        mse = nn.MSELoss()(decoded, data)
        
        # 判断是否异常
        is_anomaly = mse > self.threshold if self.threshold else False
        
        return is_anomaly, mse.item()