《激情沸点》与DeFi热度：热度作为流动性挖矿

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

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

contract HotYieldFarm is ERC20, Ownable, ReentrancyGuard {
    struct Pool {
        address lpToken;
        uint256 totalStaked;
        uint256 rewardRate;
        uint256 lastUpdateTime;
        uint256 rewardPerTokenStored;
        uint256 totalRewards;
        uint256 minStakeDuration;
        uint256 earlyWithdrawalPenalty;
        bool isActive;
    }
    
    struct Staker {
        uint256 stakedAmount;
        uint256 rewards;
        uint256 rewardPerTokenPaid;
        uint256 stakedAt;
        uint256 lastClaimTime;
    }
    
    struct HotZone {
        string name;
        uint256 multiplier;
        uint256 startTime;
        uint256 endTime;
        bool isActive;
    }
    
    mapping(uint256 => Pool) public pools;
    mapping(uint256 => mapping(address => Staker)) public stakers;
    mapping(uint256 => HotZone[]) public hotZones;
    
    uint256 public poolCount;
    uint256 public constant MAX_POOLS = 10;
    uint256 public constant REWARD_DECAY_RATE = 500; // 5% per week
    uint256 public constant MAX_REWARD_RATE = 1000 ether;
    
    uint256 public totalValueLocked;
    uint256 public peakTVL;
    uint256 public lastTVLUpdate;
    
    event PoolCreated(uint256 indexed poolId, address lpToken, uint256 rewardRate);
    event Staked(uint256 indexed poolId, address indexed user, uint256 amount);
    event Withdrawn(uint256 indexed poolId, address indexed user, uint256 amount);
    event RewardsClaimed(uint256 indexed poolId, address indexed user, uint256 amount);
    event HotZoneActivated(uint256 indexed poolId, string name, uint256 multiplier);
    event TVLUpdated(uint256 tvl, uint256 timestamp);
    
    constructor() ERC20("HotYield", "HOTY") {}
    
    function createPool(
        address _lpToken,
        uint256 _rewardRate,
        uint256 _minStakeDuration,
        uint256 _earlyWithdrawalPenalty
    ) external onlyOwner {
        require(poolCount < MAX_POOLS, "Max pools reached");
        require(_rewardRate <= MAX_REWARD_RATE, "Rate too high");
        
        poolCount++;
        pools[poolCount] = Pool({
            lpToken: _lpToken,
            totalStaked: 0,
            rewardRate: _rewardRate,
            lastUpdateTime: block.timestamp,
            rewardPerTokenStored: 0,
            totalRewards: 0,
            minStakeDuration: _minStakeDuration,
            earlyWithdrawalPenalty: _earlyWithdrawalPenalty,
            isActive: true
        });
        
        emit PoolCreated(poolCount, _lpToken, _rewardRate);
    }
    
    function stake(uint256 _poolId, uint256 _amount) external nonReentrant {
        Pool storage pool = pools[_poolId];
        require(pool.isActive, "Pool not active");
        require(_amount > 0, "Amount must be > 0");
        
        updateReward(_poolId, msg.sender);
        
        Staker storage staker = stakers[_poolId][msg.sender];
        
        IERC20(pool.lpToken).transferFrom(msg.sender, address(this), _amount);
        
        staker.stakedAmount += _amount;
        staker.stakedAt = block.timestamp;
        pool.totalStaked += _amount;
        
        totalValueLocked += _amount;
        if (totalValueLocked > peakTVL) {
            peakTVL = totalValueLocked;
        }
        
        emit Staked(_poolId, msg.sender, _amount);
        emit TVLUpdated(totalValueLocked, block.timestamp);
    }
    
    function withdraw(uint256 _poolId, uint256 _amount) external nonReentrant {
        Pool storage pool = pools[_poolId];
        Staker storage staker = stakers[_poolId][msg.sender];
        
        require(_amount > 0, "Amount must be > 0");
        require(staker.stakedAmount >= _amount, "Insufficient stake");
        
        updateReward(_poolId, msg.sender);
        
        // 检查锁仓期
        uint256 stakedDuration = block.timestamp - staker.stakedAt;
        uint256 penalty = 0;
        
        if (stakedDuration < pool.minStakeDuration) {
            penalty = (_amount * pool.earlyWithdrawalPenalty) / 10000;
        }
        
        staker.stakedAmount -= _amount;
        pool.totalStaked -= _amount;
        totalValueLocked -= _amount;
        
        uint256 withdrawAmount = _amount - penalty;
        
        IERC20(pool.lpToken).transfer(msg.sender, withdrawAmount);
        
        // 惩罚金分配给其他质押者
        if (penalty > 0) {
            // 将惩罚金加入奖励池
            pool.totalRewards += penalty;
        }
        
        emit Withdrawn(_poolId, msg.sender, _amount);
        emit TVLUpdated(totalValueLocked, block.timestamp);
    }
    
    function claimRewards(uint256 _poolId) external nonReentrant {
        updateReward(_poolId, msg.sender);
        
        Staker storage staker = stakers[_poolId][msg.sender];
        uint256 reward = staker.rewards;
        
        require(reward > 0, "No rewards to claim");
        
        staker.rewards = 0;
        staker.lastClaimTime = block.timestamp;
        
        _mint(msg.sender, reward);
        
        emit RewardsClaimed(_poolId, msg.sender, reward);
    }
    
    function updateReward(uint256 _poolId, address _user) internal {
        Pool storage pool = pools[_poolId];
        Staker storage staker = stakers[_poolId][_user];
        
        pool.rewardPerTokenStored = rewardPerToken(_poolId);
        pool.lastUpdateTime = block.timestamp;
        
        if (_user != address(0)) {
            staker.rewards = earned(_poolId, _user);
            staker.rewardPerTokenPaid = pool.rewardPerTokenStored;
        }
    }
    
    function rewardPerToken(uint256 _poolId) public view returns (uint256) {
        Pool storage pool = pools[_poolId];
        
        if (pool.totalStaked == 0) {
            return pool.rewardPerTokenStored;
        }
        
        uint256 rewardMultiplier = getActiveMultiplier(_poolId);
        uint256 effectiveRate = (pool.rewardRate * rewardMultiplier) / 1e18;
        
        return pool.rewardPerTokenStored + (
            (effectiveRate * (block.timestamp - pool.lastUpdateTime) * 1e18) / pool.totalStaked
        );
    }
    
    function earned(uint256 _poolId, address _user) public view returns (uint256) {
        Pool storage pool = pools[_poolId];
        Staker storage staker = stakers[_poolId][_user];
        
        return ((staker.stakedAmount * (
            rewardPerToken(_poolId) - staker.rewardPerTokenPaid
        )) / 1e18) + staker.rewards;
    }
    
    function getAPY(uint256 _poolId) external view returns (uint256) {
        Pool storage pool = pools[_poolId];
        uint256 annualReward = pool.rewardRate * 365 days;
        
        if (pool.totalStaked == 0) {
            return 0;
        }
        
        return (annualReward * 10000) / pool.totalStaked;
    }
    
    // 激活"热度区"
    function activateHotZone(
        uint256 _poolId,
        string memory _name,
        uint256 _multiplier,
        uint256 _duration
    ) external onlyOwner {
        hotZones[_poolId].push(HotZone({
            name: _name,
            multiplier: _multiplier,
            startTime: block.timestamp,
            endTime: block.timestamp + _duration,
            isActive: true
        }));
        
        emit HotZoneActivated(_poolId, _name, _multiplier);
    }
    
    function getActiveMultiplier(uint256 _poolId) public view returns (uint256) {
        HotZone[] storage zones = hotZones[_poolId];
        uint256 multiplier = 1e18; // 默认1x
        
        for (uint256 i = 0; i < zones.length; i++) {
            if (zones[i].isActive &&
                block.timestamp >= zones[i].startTime &&
                block.timestamp <= zones[i].endTime) {
                multiplier = multiplier > zones[i].multiplier 
                    ? multiplier : zones[i].multiplier;
            }
        }
        
        return multiplier;
    }
    
    function getPoolTVL(uint256 _poolId) external view returns (uint256) {
        return pools[_poolId].totalStaked;
    }
    
    function getHeatIndex(uint256 _poolId) external view returns (uint256) {
        Pool storage pool = pools[_poolId];
        
        if (pool.totalStaked == 0) {
            return 0;
        }
        
        // 热度指数 = 奖励率 / 总质押量 * 10000
        uint256 heatIndex = (pool.rewardRate * 10000) / pool.totalStaked;
        
        // 考虑热度区加成
        uint256 multiplier = getActiveMultiplier(_poolId);
        heatIndex = (heatIndex * multiplier) / 1e18;
        
        return heatIndex;
    }
}

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List, Tuple
import matplotlib.pyplot as plt
import seaborn as sns
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class PoolMetrics:
    pool_id: int
    tvl: float
    apy: float
    total_users: int
    daily_volume: float
    reward_rate: float
    heat_index: float
    timestamp: datetime

class DeFiHeatAnalyzer:
    def __init__(self):
        self.pool_history = []
        self.heat_events = []
        self.user_behavior = defaultdict(list)
        
    def simulate_pool_metrics(self, days: int = 365) -> pd.DataFrame:
        """模拟池子指标，就像模拟电影的热度曲线"""
        np.random.seed(42)
        
        # 初始参数
        initial_tvl = 1000000  # $1M
        base_apy = 50  # 50%
        
        metrics = []
        tvl = initial_tvl
        apy = base_apy
        
        # 周期性热度事件
        hot_events = [
            {'day': 30, 'duration': 15, 'multiplier': 3},
            {'day': 90, 'duration': 20, 'multiplier': 5},
            {'day': 180, 'duration': 10, 'multiplier': 2},
            {'day': 270, 'duration': 25, 'multiplier': 4},
        ]
        
        for day in range(days):
            # 检查是否在热度事件中
            in_hot_zone = False
            multiplier = 1
            for event in hot_events:
                if event['day'] <= day < event['day'] + event['duration']:
                    in_hot_zone = True
                    multiplier = event['multiplier']
                    break
            
            # TVL动态
            if in_hot_zone:
                tvl_growth = np.random.normal(0.05, 0.02) * multiplier
            else:
                tvl_growth = np.random.normal(0.01, 0.01)
            
            # 热度衰减
            decay = 1 - (day / days) * 0.3
            
            tvl = tvl * (1 + tvl_growth) * decay
            apy = base_apy * multiplier * np.random.uniform(0.8, 1.2)
            
            # 防止负值
            tvl = max(tvl, 1000)
            apy = max(apy, 1)
            
            # 用户数量
            if in_hot_zone:
                new_users = int(np.random.poisson(50 * multiplier))
            else:
                new_users = int(np.random.poisson(10))
            
            total_users = int(tvl / 1000)  # 假设平均每人$1000
            daily_volume = tvl * np.random.uniform(0.02, 0.08)
            
            # 热度指数
            heat_index = (apy * 100) / (tvl / 1000000) * multiplier
            
            metrics.append({
                'day': day,
                'tvl': tvl,
                'apy': apy,
                'total_users': total_users,
                'daily_volume': daily_volume,
                'reward_rate': apy * tvl / 100,
                'heat_index': heat_index,
                'in_hot_zone': in_hot_zone,
                'multiplier': multiplier
            })
            
            # 记录热度事件
            if in_hot_zone and not self.heat_events:
                self.heat_events.append({
                    'start_day': day,
                    'multiplier': multiplier,
                    'peak_tvl': tvl,
                    'peak_apy': apy
                })
        
        return pd.DataFrame(metrics)
    
    def detect_heat_waves(self, df: pd.DataFrame, threshold: float = 0.8) -> List[Dict]:
        """检测热浪事件，就像检测电影的热度高峰"""
        heat_waves = []
        
        max_heat = df['heat_index'].max()
        in_wave = False
        wave_start = None
        
        for _, row in df.iterrows():
            normalized_heat = row['heat_index'] / max_heat if max_heat > 0 else 0
            
            if normalized_heat > threshold and not in_wave:
                in_wave = True
                wave_start = row['day']
            elif normalized_heat <= threshold and in_wave:
                in_wave = False
                heat_waves.append({
                    'start_day': wave_start,
                    'end_day': row['day'],
                    'duration': row['day'] - wave_start,
                    'peak_heat': df[(df['day'] >= wave_start) & 
                                   (df['day'] <= row['day'])]['heat_index'].max()
                })
        
        return heat_waves
    
    def analyze_fomo_cycle(self, df: pd.DataFrame) -> Dict:
        """分析FOMO周期，就像分析观众的情绪曲线"""
        # 识别FOMO阶段
        fomo_phases = []
        
        for i in range(1, len(df)):
            prev_tvl = df.iloc[i-1]['tvl']
            curr_tvl = df.iloc[i]['tvl']
            prev_apy = df.iloc[i-1]['apy']
            curr_apy = df.iloc[i]['apy']
            
            # TVL和APY同时上升 = FOMO阶段
            if curr_tvl > prev_tvl * 1.02 and curr_apy > prev_apy * 1.02:
                fomo_phases.append({
                    'day': df.iloc[i]['day'],
                    'tvl_growth': (curr_tvl - prev_tvl) / prev_tvl,
                    'apy_growth': (curr_apy - prev_apy) / prev_apy
                })
        
        # 分析FOMO的强度
        if fomo_phases:
            avg_tvl_growth = np.mean([f['tvl_growth'] for f in fomo_phases])
            avg_apy_growth = np.mean([f['apy_growth'] for f in fomo_phases])
            total_fomo_days = len(fomo_phases)
        else:
            avg_tvl_growth = 0
            avg_apy_growth = 0
            total_fomo_days = 0
        
        # 检测"热度泡沫"破裂
        crash_detected = False
        crash_day = None
        for i in range(1, len(df)):
            if df.iloc[i]['tvl'] < df.iloc[i-1]['tvl'] * 0.7:  # 30%以上的TVL暴跌
                crash_detected = True
                crash_day = df.iloc[i]['day']
                break
        
        return {
            'total_fomo_days': total_fomo_days,
            'avg_tvl_growth_per_fomo': avg_tvl_growth,
            'avg_apy_growth_per_fomo': avg_apy_growth,
            'crash_detected': crash_detected,
            'crash_day': crash_day,
            'fomo_intensity': avg_tvl_growth * avg_apy_growth * total_fomo_days
        }
    
    def calculate_impermanent_loss_risk(
        self, price_volatility: float = 0.3, pool_share: float = 0.1
    ) -> Dict:
        """计算无常损失风险，就像评估投资风险"""
        # 无常损失公式: IL = 2 * sqrt(k) / (1 + k) - 1
        # 其中 k = P_new / P_old (价格变化比)
        
        price_ratios = np.linspace(0.5, 2.0, 100)
        impermanent_losses = []
        
        for ratio in price_ratios:
            il = 2 * np.sqrt(ratio) / (1 + ratio) - 1
            impermanent_losses.append(abs(il))
        
        max_il = max(impermanent_losses)
        expected_il = np.mean(impermanent_losses)
        
        # 考虑APY补偿
        apy_needed_to_compensate = expected_il * 100  # 需要的APY来补偿无常损失
        
        return {
            'max_impermanent_loss': max_il,
            'expected_impermanent_loss': expected_il,
            'apy_needed_to_compensate': apy_needed_to_compensate,
            'risk_level': '高' if max_il > 0.1 else '中' if max_il > 0.05 else '低',
            'price_volatility': price_volatility
        }
    
    def simulate_rug_pull_risk(self, df: pd.DataFrame) -> Dict:
        """模拟Rug Pull风险，就像分析犯罪率"""
        risk_indicators = {
            'sudden_apy_spike': False,
            'anonymous_team': False,
            'locked_liquidity': False,
            'audit_status': False,
            'social_media_activity': False
        }
        
        # 检查APY是否突然飙升（可能是诱饵）
        max_apy_change = df['apy'].pct_change().max()
        if max_apy_change > 2:  # 200%以上的APY变化
            risk_indicators['sudden_apy_spike'] = True
        
        # 计算综合风险评分
        risk_score = sum(1 for v in risk_indicators.values() if v) / len(risk_indicators)
        
        return {
            'risk_indicators': risk_indicators,
            'risk_score': risk_score,
            'risk_level': '高' if risk_score > 0.6 else '中' if risk_score > 0.3 else '低',
            'max_apy_change': max_apy_change
        }
    
    def visualize_heat_analysis(self, df: pd.DataFrame):
        """可视化热度分析"""
        fig, axes = plt.subplots(2, 2, figsize=(14, 12))
        
        # 1. TVL和APY曲线
        ax1 = axes[0, 0]
        ax1_twin = ax1.twinx()
        
        ax1.plot(df['day'], df['tvl'], color='blue', label='TVL', linewidth=2)
        ax1_twin.plot(df['day'], df['apy'], color='red', label='APY', linewidth=2, alpha=0.7)
        
        # 标记热度区
        hot_days = df[df['in_hot_zone']]
        ax1.fill_between(hot_days['day'], 0, df['tvl'].max(), 
                        color='orange', alpha=0.1, label='热度区')
        
        ax1.set_xlabel('天数')
        ax1.set_ylabel('TVL ($)', color='blue')
        ax1_twin.set_ylabel('APY (%)', color='red')
        ax1.set_title('TVL与APY动态')
        
        lines1, labels1 = ax1.get_legend_handles_labels()
        lines2, labels2 = ax1_twin.get_legend_handles_labels()
        ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left')
        
        # 2. 热度指数热力图
        ax2 = axes[0, 1]
        heat_data = df[['day', 'heat_index']].copy()
        heat_data['heat_category'] = pd.cut(
            heat_data['heat_index'], 
            bins=5, 
            labels=['极低', '低', '中', '高', '极高']
        )
        heat_pivot = heat_data.pivot_table(
            index='heat_category', 
            aggfunc='count'
        )
        sns.heatmap(heat_pivot[['day']], ax=ax2, cmap='YlOrRd', 
                   annot=True, fmt='d', cbar_kws={'label': '天数'})
        ax2.set_title('热度指数分布')
        
        # 3. 用户增长与TVL关系
        ax3 = axes[1, 0]
        scatter = ax3.scatter(
            df['total_users'], df['tvl'], 
            c=df['heat_index'], cmap='hot', alpha=0.6, s=30
        )
        plt.colorbar(scatter, ax=ax3, label='热度指数')
        ax3.set_xlabel('用户数')
        ax3.set_ylabel('TVL ($)')
        ax3.set_title('用户增长与TVL关系')
        
        # 4. FOMO周期分析
        ax4 = axes[1, 1]
        fomo = self.analyze_fomo_cycle(df)
        metrics_names = ['FOMO天数', 'TVL增长率', 'APY增长率', 'FOMO强度']
        metrics_values = [
            fomo['total_fomo_days'],
            fomo['avg_tvl_growth_per_fomo'] * 100,
            fomo['avg_apy_growth_per_fomo'] * 100,
            fomo['fomo_intensity'] * 1000
        ]
        ax4.bar(metrics_names, metrics_values, color=['red', 'orange', 'yellow', 'darkred'])
        ax4.set_title('FOMO周期分析')
        ax4.set_xticklabels(metrics_names, rotation=45, ha='right')
        ax4.set_ylabel('数值')
        
        plt.tight_layout()
        return plt
    
    def generate_heat_report(self, df: pd.DataFrame) -> str:
        """生成热度报告"""
        heat_waves = self.detect_heat_waves(df)
        fomo = self.analyze_fomo_cycle(df)
        rug_risk = self.simulate_rug_pull_risk(df)
        
        report = f"""
=== DeFi热度分析报告 ===

【池子概况】
平均TVL: ${df['tvl'].mean():,.0f}
峰值TVL: ${df['tvl'].max():,.0f}
平均APY: {df['apy'].mean():.1f}%
峰值APY: {df['apy'].max():.1f}%
总用户数: {df['total_users'].iloc[-1]:,}

【热浪事件】
检测到 {len(heat_waves)} 次热浪
平均热浪持续时间: {np.mean([h['duration'] for h in heat_waves]) if heat_waves else 0:.1f} 天
最强热浪峰值热度: {max([h['peak_heat'] for h in heat_waves]) if heat_waves else 0:.2f}

【FOMO分析】
总FOMO天数: {fomo['total_fomo_days']} 天
崩溃检测: {'是' if fomo['crash_detected'] else '否'}
FOMO强度: {fomo['fomo_intensity']:.4f}

【风险分析】
Rug Pull风险: {rug_risk['risk_level']}
风险评分: {rug_risk['risk_score']:.2%}
无常损失风险: 最大 {self.calculate_impermanent_loss_risk()['max_impermanent_loss']:.2%}
"""
        return report


# 使用示例
if __name__ == "__main__":
    analyzer = DeFiHeatAnalyzer()
    
    df = analyzer.simulate_pool_metrics(days=365)
    print(f"模拟完成: {len(df)} 天数据")
    
    heat_waves = analyzer.detect_heat_waves(df)
    print(f"检测到 {len(heat_waves)} 次热浪")
    
    fomo = analyzer.analyze_fomo_cycle(df)
    print(f"FOMO强度: {fomo['fomo_intensity']:.4f}")
    
    report = analyzer.generate_heat_report(df)
    print(report)

// DeFi热度实时监控看板
const Web3 = require('web3');
const axios = require('axios');

class DeFiHeatMonitor {
    constructor() {
        this.pools = new Map();
        this.heatHistory = [];
        this.alerts = [];
        this.heatThresholds = {
            warning: 70,
            danger: 90,
            fomo: 95
        };
    }
    
    // 更新池子数据
    updatePoolData(poolId, data) {
        const pool = this.pools.get(poolId) || {
            tvlHistory: [],
            apyHistory: [],
            heatIndex: 0,
            alerts: []
        };
        
        pool.tvlHistory.push({
            value: data.tvl,
            timestamp: Date.now()
        });
        
        pool.apyHistory.push({
            value: data.apy,
            timestamp: Date.now()
        });
        
        pool.heatIndex = this.calculateHeatIndex(data);
        pool.currentData = data;
        
        this.pools.set(poolId, pool);
        
        // 检查是否触发警报
        this.checkHeatAlerts(poolId, pool);
        
        return pool;
    }
    
    calculateHeatIndex(data) {
        const factors = {
            apy: data.apy / 1000, // APY归一化
            tvl: data.tvl / 10000000, // TVL归一化
            volume: data.dailyVolume / 1000000,
            users: data.totalUsers / 1000
        };
        
        const weights = {
            apy: 0.35,
            tvl: 0.25,
            volume: 0.20,
            users: 0.20
        };
        
        let heatIndex = 0;
        for (const [factor, weight] of Object.entries(weights)) {
            heatIndex += Math.min(1, factors[factor]) * weight;
        }
        
        return Math.min(100, heatIndex * 100);
    }
    
    checkHeatAlerts(poolId, pool) {
        const heatIndex = pool.heatIndex;
        
        if (heatIndex >= this.heatThresholds.fomo && 
            !pool.fomoAlerted) {
            this.triggerAlert({
                type: 'FOMO_ALERT',
                poolId,
                heatIndex,
                message: `⚠️ 极度FOMO! 池子 ${poolId} 热度达到 ${heatIndex.toFixed(1)}%`,
                severity: 'critical'
            });
            pool.fomoAlerted = true;
        } else if (heatIndex >= this.heatThresholds.danger) {
            this.triggerAlert({
                type: 'DANGER_ALERT',
                poolId,
                heatIndex,
                message: `🔥 高风险! 池子 ${poolId} 热度达到 ${heatIndex.toFixed(1)}%`,
                severity: 'high'
            });
        } else if (heatIndex >= this.heatThresholds.warning) {
            this.triggerAlert({
                type: 'WARNING_ALERT',
                poolId,
                heatIndex,
                message: `⚡ 关注! 池子 ${poolId} 热度达到 ${heatIndex.toFixed(1)}%`,
                severity: 'medium'
            });
        }
    }
    
    triggerAlert(alert) {
        this.alerts.push({
            ...alert,
            timestamp: new Date()
        });
        console.log(`[警报] ${alert.severity}: ${alert.message}`);
    }
    
    getPoolRecommendations() {
        const recommendations = [];
        
        for (const [poolId, pool] of this.pools) {
            const heatIndex = pool.heatIndex;
            const apyTrend = this.getTrend(pool.apyHistory);
            const tvlTrend = this.getTrend(pool.tvlHistory);
            
            if (heatIndex < 30 && apyTrend > 0) {
                recommendations.push({
                    poolId,
                    action: 'BUY',
                    reason: '低热度+上升趋势，可能是入场好时机',
                    confidence: '高'
                });
            } else if (heatIndex > 80 && tvlTrend < 0) {
                recommendations.push({
                    poolId,
                    action: 'SELL',
                    reason: '高热度+TVL下降，可能即将崩盘',
                    confidence: '高'
                });
            } else if (heatIndex > 60 && apyTrend > 0) {
                recommendations.push({
                    poolId,
                    action: 'HOLD',
                    reason: '中等热度+上升趋势，继续持有观察',
                    confidence: '中'
                });
            }
        }
        
        return recommendations;
    }
    
    getTrend(history) {
        if (history.length < 10) return 0;
        
        const recent = history.slice(-10);
        const values = recent.map(h => h.value);
        const firstHalf = values.slice(0, 5);
        const secondHalf = values.slice(5);
        
        const firstAvg = firstHalf.reduce((a, b) => a + b, 0) / 5;
        const secondAvg = secondHalf.reduce((a, b) => a + b, 0) / 5;
        
        return (secondAvg - firstAvg) / firstAvg;
    }
    
    generateHeatMap() {
        const heatMap = [];
        
        for (const [poolId, pool] of this.pools) {
            heatMap.push({
                poolId,
                heatIndex: pool.heatIndex,
                tvl: pool.currentData?.tvl || 0,
                apy: pool.currentData?.apy || 0,
                trend: this.getTrend(pool.tvlHistory)
            });
        }
        
        return heatMap.sort((a, b) => b.heatIndex - a.heatIndex);
    }
}

// 使用示例
const monitor = new DeFiHeatMonitor();

// 模拟数据更新
setInterval(() => {
    const mockData = {
        tvl: Math.random() * 10000000,
        apy: Math.random() * 500,
        dailyVolume: Math.random() * 5000000,
        totalUsers: Math.floor(Math.random() * 1000)
    };
    
    const pool = monitor.updatePoolData('pool_1', mockData);
    console.log(`热度: ${pool.heatIndex.toFixed(1)}%`);
    
    const recommendations = monitor.getPoolRecommendations();
    if (recommendations.length > 0) {
        console.log('建议:', recommendations[0].action, recommendations[0].reason);
    }
}, 5000);