《U形转弯》与DeFi循环：U形作为流动性循环

// 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 UTurnLoop is ERC20, Ownable, ReentrancyGuard {
    struct LoopPool {
        string name;
        address lpToken;
        uint256 totalDeposits;
        uint256 currentBalance;
        uint256 yieldRate;
        uint256 feeRate;
        uint256 position;
        bool isActive;
    }
    
    struct LoopPath {
        uint256[] poolOrder;
        uint256 totalSteps;
        uint256 currentStep;
        uint256 initialAmount;
        uint256 currentAmount;
        uint256 feesPaid;
        uint256 yieldEarned;
        bool isComplete;
        address user;
        uint256 startTime;
    }
    
    struct UTurnMetrics {
        uint256 totalLoops;
        uint256 totalVolume;
        uint256 totalFees;
        uint256 totalYield;
        uint256 averageLoopTime;
        uint256 totalUsers;
    }
    
    mapping(uint256 => LoopPool) public pools;
    mapping(uint256 => LoopPath) public loopPaths;
    mapping(address => uint256[]) public userLoops;
    
    uint256 public poolCount;
    uint256 public loopCount;
    
    UTurnMetrics public metrics;
    
    uint256 public constant MIN_LOOP_AMOUNT = 0.1 ether;
    uint256 public constant MAX_LOOP_DEPTH = 10;
    uint256 public constant BASE_YIELD = 100; // 1%
    
    event PoolCreated(uint256 indexed poolId, string name, uint256 yieldRate);
    event LoopStarted(uint256 indexed loopId, address indexed user, uint256 amount, uint256 steps);
    event LoopStepCompleted(uint256 indexed loopId, uint256 step, uint256 amount, uint256 fee);
    event LoopCompleted(uint256 indexed loopId, uint256 finalAmount, uint256 totalYield);
    event UTurnDetected(uint256 indexed loopId, string message);
    
    constructor() ERC20("UTurnToken", "UTURN") {}
    
    function createPool(
        string memory _name,
        address _lpToken,
        uint256 _yieldRate,
        uint256 _feeRate
    ) external onlyOwner {
        poolCount++;
        pools[poolCount] = LoopPool({
            name: _name,
            lpToken: _lpToken,
            totalDeposits: 0,
            currentBalance: 0,
            yieldRate: _yieldRate,
            feeRate: _feeRate,
            position: 0,
            isActive: true
        });
        
        emit PoolCreated(poolCount, _name, _yieldRate);
    }
    
    function startLoop(
        uint256[] memory _poolOrder,
        uint256 _amount
    ) external payable nonReentrant {
        require(msg.value >= _amount, "Insufficient funds");
        require(_amount >= MIN_LOOP_AMOUNT, "Amount too small");
        require(_poolOrder.length <= MAX_LOOP_DEPTH, "Loop too deep");
        require(_poolOrder.length >= 2, "Need at least 2 pools");
        
        // 验证所有池子都存在
        for (uint256 i = 0; i < _poolOrder.length; i++) {
            require(pools[_poolOrder[i]].isActive, "Pool not active");
        }
        
        loopCount++;
        loopPaths[loopCount] = LoopPath({
            poolOrder: _poolOrder,
            totalSteps: _poolOrder.length,
            currentStep: 0,
            initialAmount: _amount,
            currentAmount: _amount,
            feesPaid: 0,
            yieldEarned: 0,
            isComplete: false,
            user: msg.sender,
            startTime: block.timestamp
        });
        
        userLoops[msg.sender].push(loopCount);
        
        metrics.totalLoops++;
        metrics.totalUsers++;
        metrics.totalVolume += _amount;
        
        emit LoopStarted(loopCount, msg.sender, _amount, _poolOrder.length);
        
        // 执行第一步
        executeLoopStep(loopCount);
    }
    
    function executeLoopStep(uint256 _loopId) internal {
        LoopPath storage loop = loopPaths[_loopId];
        
        require(!loop.isComplete, "Loop already complete");
        require(loop.currentStep < loop.totalSteps, "All steps done");
        
        uint256 poolId = loop.poolOrder[loop.currentStep];
        LoopPool storage pool = pools[poolId];
        
        // 计算收益和费用
        uint256 yieldAmount = (loop.currentAmount * pool.yieldRate) / 10000;
        uint256 feeAmount = (loop.currentAmount * pool.feeRate) / 10000;
        
        loop.currentAmount = loop.currentAmount + yieldAmount - feeAmount;
        loop.yieldEarned += yieldAmount;
        loop.feesPaid += feeAmount;
        pool.currentBalance += loop.currentAmount;
        
        metrics.totalFees += feeAmount;
        metrics.totalYield += yieldAmount;
        
        emit LoopStepCompleted(_loopId, loop.currentStep, loop.currentAmount, feeAmount);
        
        loop.currentStep++;
        
        // 检查是否完成循环
        if (loop.currentStep >= loop.totalSteps) {
            completeLoop(_loopId);
        }
    }
    
    function completeLoop(uint256 _loopId) internal {
        LoopPath storage loop = loopPaths[_loopId];
        loop.isComplete = true;
        
        uint256 totalReturn = loop.currentAmount;
        uint256 netProfit = totalReturn > loop.initialAmount 
            ? totalReturn - loop.initialAmount 
            : 0;
        
        // 检测U形模式
        if (netProfit < loop.feesPaid) {
            emit UTurnDetected(_loopId, "U形循环：收益小于费用，资金在循环中消耗");
        }
        
        // 返还资金
        payable(loop.user).transfer(totalReturn);
        
        emit LoopCompleted(_loopId, totalReturn, loop.yieldEarned);
    }
    
    function continueLoop(uint256 _loopId) external nonReentrant {
        LoopPath storage loop = loopPaths[_loopId];
        require(loop.user == msg.sender, "Not loop owner");
        require(!loop.isComplete, "Loop already complete");
        
        executeLoopStep(_loopId);
    }
    
    function getLoopStatus(uint256 _loopId)
        external view returns (
            uint256 currentAmount,
            uint256 currentStep,
            uint256 totalSteps,
            uint256 feesPaid,
            uint256 yieldEarned,
            bool isComplete
        )
    {
        LoopPath storage loop = loopPaths[_loopId];
        return (
            loop.currentAmount,
            loop.currentStep,
            loop.totalSteps,
            loop.feesPaid,
            loop.yieldEarned,
            loop.isComplete
        );
    }
    
    function getUserLoops(address _user)
        external view returns (uint256[] memory)
    {
        return userLoops[_user];
    }
    
    function getMetrics() external view returns (UTurnMetrics memory) {
        return metrics;
    }
    
    function calculateLoopEfficiency(uint256 _loopId)
        external view returns (uint256)
    {
        LoopPath storage loop = loopPaths[_loopId];
        
        if (loop.feesPaid == 0) return 10000;
        
        // 效率 = (净收益 / 总收益) * 10000
        uint256 netReturn = loop.currentAmount > loop.initialAmount
            ? loop.currentAmount - loop.initialAmount
            : 0;
        
        uint256 grossReturn = loop.currentAmount - loop.initialAmount + loop.feesPaid;
        
        if (grossReturn == 0) return 0;
        
        return (netReturn * 10000) / grossReturn;
    }
}

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

@dataclass
class LoopStep:
    pool_id: int
    pool_name: str
    amount_in: float
    amount_out: float
    yield_earned: float
    fee_paid: float
    timestamp: datetime

@dataclass
class LoopPath:
    loop_id: int
    user: str
    initial_amount: float
    final_amount: float
    steps: List[LoopStep]
    total_fees: float
    total_yield: float
    start_time: datetime
    end_time: datetime
    is_complete: bool

class UTurnAnalyzer:
    def __init__(self):
        self.loops = []
        self.pool_stats = defaultdict(lambda: {
            'total_volume': 0,
            'total_fees': 0,
            'total_yield': 0,
            'usage_count': 0
        })
        
    def simulate_loop(self, initial_amount: float, num_steps: int = 5) -> LoopPath:
        """模拟U形循环，就像导演编排一个循环场景"""
        np.random.seed(int(datetime.now().timestamp()))
        
        # 池子名称
        pool_names = ['Pool_A', 'Pool_B', 'Pool_C', 'Pool_D', 'Pool_E']
        
        current_amount = initial_amount
        steps = []
        total_fees = 0
        total_yield = 0
        
        for i in range(num_steps):
            pool_id = i % len(pool_names) + 1
            pool_name = pool_names[i % len(pool_names)]
            
            # 收益率（递减，模拟收益递减效应）
            yield_rate = np.random.uniform(0.005, 0.02) * (1 - i * 0.1)
            yield_earned = current_amount * yield_rate
            
            # 费用率（递增，模拟循环费用累积）
            fee_rate = 0.003 * (1 + i * 0.2)
            fee_paid = current_amount * fee_rate
            
            amount_out = current_amount + yield_earned - fee_paid
            
            step = LoopStep(
                pool_id=pool_id,
                pool_name=pool_name,
                amount_in=current_amount,
                amount_out=amount_out,
                yield_earned=yield_earned,
                fee_paid=fee_paid,
                timestamp=datetime.now() + timedelta(minutes=i * 5)
            )
            
            steps.append(step)
            current_amount = amount_out
            total_fees += fee_paid
            total_yield += yield_earned
            
            # 更新池子统计
            stats = self.pool_stats[pool_name]
            stats['total_volume'] += amount_out
            stats['total_fees'] += fee_paid
            stats['total_yield'] += yield_earned
            stats['usage_count'] += 1
        
        loop = LoopPath(
            loop_id=len(self.loops) + 1,
            user=f'0xuser{np.random.randint(1, 100)}',
            initial_amount=initial_amount,
            final_amount=current_amount,
            steps=steps,
            total_fees=total_fees,
            total_yield=total_yield,
            start_time=datetime.now(),
            end_time=datetime.now() + timedelta(minutes=num_steps * 5),
            is_complete=True
        )
        
        self.loops.append(loop)
        return loop
    
    def analyze_loop_efficiency(self, loop: LoopPath) -> Dict:
        """分析循环效率，就像评估场景的叙事效率"""
        net_return = loop.final_amount - loop.initial_amount
        gross_return = loop.total_yield
        efficiency = net_return / gross_return if gross_return > 0 else 0
        
        # 分析每一步的贡献
        step_contributions = []
        for i, step in enumerate(loop.steps):
            step_net = step.amount_out - step.amount_in
            step_contributions.append({
                'step': i + 1,
                'pool': step.pool_name,
                'net_contribution': step_net,
                'yield_contribution': step.yield_earned,
                'fee_impact': step.fee_paid,
                'efficiency': step_net / step.amount_in if step.amount_in > 0 else 0
            })
        
        # 检测"U形"效应（收益递减）
        diminishing_returns = []
        for i in range(1, len(step_contributions)):
            prev_eff = step_contributions[i-1]['efficiency']
            curr_eff = step_contributions[i]['efficiency']
            diminishing_returns.append({
                'transition': f"Step {i} -> {i+1}",
                'efficiency_change': curr_eff - prev_eff,
                'is_diminishing': curr_eff < prev_eff
            })
        
        return {
            'loop_id': loop.loop_id,
            'initial_amount': loop.initial_amount,
            'final_amount': loop.final_amount,
            'net_return': net_return,
            'total_fees': loop.total_fees,
            'total_yield': loop.total_yield,
            'efficiency': efficiency,
            'roi': (net_return / loop.initial_amount) * 100,
            'step_contributions': step_contributions,
            'diminishing_returns': diminishing_returns,
            'is_profitable': net_return > 0,
            'u_turn_effect': '收益递减' if any(d['is_diminishing'] for d in diminishing_returns) else '收益递增'
        }
    
    def simulate_multiple_loops(
        self, count: int = 100, base_amount: float = 10.0
    ) -> List[Dict]:
        """模拟多个循环，就像分析多个版本的剧本"""
        results = []
        
        for i in range(count):
            amount = base_amount * np.random.uniform(0.5, 2.0)
            steps = np.random.randint(3, 8)
            loop = self.simulate_loop(amount, steps)
            analysis = self.analyze_loop_efficiency(loop)
            results.append(analysis)
        
        return results
    
    def analyze_loop_patterns(self, results: List[Dict]) -> Dict:
        """分析循环模式，就像识别剧本中的重复结构"""
        df = pd.DataFrame(results)
        
        # 基本统计
        stats = {
            'total_loops': len(results),
            'profitable_loops': sum(1 for r in results if r['is_profitable']),
            'avg_efficiency': df['efficiency'].mean(),
            'avg_roi': df['roi'].mean(),
            'avg_fees': df['total_fees'].mean(),
            'avg_yield': df['total_yield'].mean(),
            'max_roi': df['roi'].max(),
            'min_roi': df['roi'].min()
        }
        
        stats['profit_rate'] = stats['profitable_loops'] / stats['total_loops'] * 100
        
        # U形效应分析
        u_turn_effects = df['u_turn_effect'].value_counts()
        stats['u_turn_effect_distribution'] = u_turn_effects.to_dict()
        
        # 寻找最优循环步数
        step_efficiency = df.groupby(
            df['step_contributions'].apply(len)
        )['efficiency'].mean()
        stats['optimal_steps'] = step_efficiency.idxmax()
        stats['optimal_steps_efficiency'] = step_efficiency.max()
        
        return stats
    
    def simulate_uturn_death_spiral(self) -> Dict:
        """模拟U形死亡螺旋，就像Bobby在电影中的命运"""
        # 初始资金
        amount = 100.0
        history = [amount]
        fees = [0]
        yields = [0]
        
        # 模拟多个循环
        for i in range(20):
            # 收益递减
            yield_rate = max(0.001, 0.02 - i * 0.001)
            fee_rate = min(0.05, 0.003 + i * 0.002)
            
            yield_earned = amount * yield_rate
            fee_paid = amount * fee_rate
            
            amount = amount + yield_earned - fee_paid
            history.append(amount)
            fees.append(fee_paid)
            yields.append(yield_earned)
            
            # 检测死亡螺旋
            if amount < history[0] * 0.5:
                break
        
        return {
            'initial_amount': history[0],
            'final_amount': amount,
            'total_cycles': len(history) - 1,
            'history': history,
            'fees': fees,
            'yields': yields,
            'death_spiral': amount < history[0],
            'survival_rate': amount / history[0] * 100
        }
    
    def visualize_uturn_analysis(self, results: List[Dict]):
        """可视化U形分析"""
        fig, axes = plt.subplots(2, 2, figsize=(14, 12))
        
        # 1. 效率分布
        ax1 = axes[0, 0]
        efficiencies = [r['efficiency'] for r in results]
        ax1.hist(efficiencies, bins=20, color='coral', edgecolor='black', alpha=0.7)
        ax1.axvline(np.mean(efficiencies), color='red', linestyle='--',
                   label=f'平均: {np.mean(efficiencies):.2%}')
        ax1.set_title('循环效率分布')
        ax1.set_xlabel('效率')
        ax1.set_ylabel('循环数量')
        ax1.legend()
        
        # 2. ROI分布
        ax2 = axes[0, 1]
        rois = [r['roi'] for r in results]
        ax2.hist(rois, bins=20, color='skyblue', edgecolor='black', alpha=0.7)
        ax2.axvline(0, color='red', linestyle='-', linewidth=2, label='盈亏平衡线')
        ax2.set_title('ROI分布')
        ax2.set_xlabel('ROI (%)')
        ax2.set_ylabel('循环数量')
        ax2.legend()
        
        # 3. U形死亡螺旋
        ax3 = axes[1, 0]
        spiral = self.simulate_uturn_death_spiral()
        ax3.plot(spiral['history'], marker='o', color='darkred', linewidth=2)
        ax3.fill_between(range(len(spiral['history'])), spiral['history'],
                        alpha=0.3, color='red')
        ax3.axhline(y=spiral['initial_amount'], color='blue', linestyle='--',
                   label=f'初始: ${spiral["initial_amount"]:.0f}')
        ax3.set_title('U形死亡螺旋')
        ax3.set_xlabel('循环次数')
        ax3.set_ylabel('金额 ($)')
        ax3.legend()
        
        # 4. 步数与效率关系
        ax4 = axes[1, 1]
        step_counts = [len(r['step_contributions']) for r in results]
        step_eff = defaultdict(list)
        for steps, eff in zip(step_counts, efficiencies):
            step_eff[steps].append(eff)
        
        steps_sorted = sorted(step_eff.keys())
        avg_eff = [np.mean(step_eff[s]) for s in steps_sorted]
        ax4.plot(steps_sorted, avg_eff, marker='s', color='green', linewidth=2)
        ax4.set_title('步数与效率关系')
        ax4.set_xlabel('循环步数')
        ax4.set_ylabel('平均效率')
        ax4.grid(True, alpha=0.3)
        
        plt.tight_layout()
        return plt
    
    def generate_uturn_report(self) -> str:
        """生成U形循环报告"""
        results = self.simulate_multiple_loops(count=50)
        stats = self.analyze_loop_patterns(results)
        spiral = self.simulate_uturn_death_spiral()
        
        report = f"""
=== U形循环分析报告 ===

【循环概况】
总循环次数: {stats['total_loops']}
盈利循环: {stats['profitable_loops']} ({stats['profit_rate']:.1f}%)
平均效率: {stats['avg_efficiency']:.2%}
平均ROI: {stats['avg_roi']:.2f}%

【效率分析】
平均费用: ${stats['avg_fees']:.2f}
平均收益: ${stats['avg_yield']:.2f}
最优步数: {stats['optimal_steps']} 步
最优效率: {stats['optimal_steps_efficiency']:.2%}

【U形效应】
U形效应分布: {stats['u_turn_effect_distribution']}

【死亡螺旋模拟】
初始金额: ${spiral['initial_amount']:.0f}
最终金额: ${spiral['final_amount']:.0f}
循环次数: {spiral['total_cycles']}
存活率: {spiral['survival_rate']:.1f}%
死亡螺旋: {'是' if spiral['death_spiral'] else '否'}

【建议】
1. 控制循环深度在 {stats['optimal_steps']} 步以内
2. 关注费用率，避免超过收益率
3. 设置止损线，防止死亡螺旋
"""
        return report


# 使用示例
if __name__ == "__main__":
    analyzer = UTurnAnalyzer()
    
    # 模拟单个循环
    loop = analyzer.simulate_loop(initial_amount=100, num_steps=5)
    analysis = analyzer.analyze_loop_efficiency(loop)
    print(f"循环 #{analysis['loop_id']}:")
    print(f"  初始: ${analysis['initial_amount']:.2f}")
    print(f"  最终: ${analysis['final_amount']:.2f}")
    print(f"  净收益: ${analysis['net_return']:.2f}")
    print(f"  效率: {analysis['efficiency']:.2%}")
    print(f"  ROI: {analysis['roi']:.2f}%")
    
    # 模拟死亡螺旋
    spiral = analyzer.simulate_uturn_death_spiral()
    print(f"\n死亡螺旋模拟:")
    print(f"  存活率: {spiral['survival_rate']:.1f}%")
    print(f"  循环次数: {spiral['total_cycles']}")
    
    report = analyzer.generate_uturn_report()
    print(report)

// U形循环实时监控看板
const Web3 = require('web3');

class UTurnMonitor {
    constructor() {
        this.activeLoops = new Map();
        this.completedLoops = [];
        this.alerts = [];
        this.thresholds = {
            maxFees: 0.1, // 费用超过10%触发警报
            minEfficiency: 0.5, // 效率低于50%触发警报
            maxSteps: 10 // 超过10步触发警报
        };
    }
    
    // 监控循环
    monitorLoop(loopData) {
        const loop = {
            id: loopData.loopId,
            user: loopData.user,
            initialAmount: loopData.amount,
            currentAmount: loopData.amount,
            step: 0,
            totalSteps: loopData.steps,
            feesPaid: 0,
            yieldEarned: 0,
            history: [{
                step: 0,
                amount: loopData.amount,
                fee: 0,
                yield: 0,
                timestamp: Date.now()
            }],
            startTime: Date.now(),
            isComplete: false
        };
        
        this.activeLoops.set(loop.id, loop);
        this.checkLoopHealth(loop);
        
        return loop;
    }
    
    // 更新循环步骤
    updateLoopStep(loopId, stepData) {
        const loop = this.activeLoops.get(loopId);
        if (!loop) return null;
        
        loop.step = stepData.step;
        loop.currentAmount = stepData.amount;
        loop.feesPaid += stepData.fee;
        loop.yieldEarned += stepData.yield;
        
        loop.history.push({
            step: stepData.step,
            amount: stepData.amount,
            fee: stepData.fee,
            yield: stepData.yield,
            timestamp: Date.now()
        });
        
        this.checkLoopHealth(loop);
        
        return loop;
    }
    
    // 完成循环
    completeLoop(loopId) {
        const loop = this.activeLoops.get(loopId);
        if (!loop) return null;
        
        loop.isComplete = true;
        loop.endTime = Date.now();
        
        const netReturn = loop.currentAmount - loop.initialAmount;
        const efficiency = loop.yieldEarned > 0 
            ? netReturn / loop.yieldEarned 
            : 0;
        
        const result = {
            ...loop,
            netReturn,
            efficiency,
            duration: (loop.endTime - loop.startTime) / 1000
        };
        
        this.completedLoops.push(result);
        this.activeLoops.delete(loopId);
        
        return result;
    }
    
    // 检查循环健康
    checkLoopHealth(loop) {
        const warnings = [];
        
        // 费用检查
        const feeRatio = loop.feesPaid / loop.initialAmount;
        if (feeRatio > this.thresholds.maxFees) {
            warnings.push({
                type: 'HIGH_FEES',
                severity: 'warning',
                message: `费用率 ${(feeRatio * 100).toFixed(1)}% 超过阈值`
            });
        }
        
        // 效率检查
        const currentEfficiency = loop.yieldEarned > 0
            ? (loop.currentAmount - loop.initialAmount) / loop.yieldEarned
            : 0;
        if (currentEfficiency < this.thresholds.minEfficiency) {
            warnings.push({
                type: 'LOW_EFFICIENCY',
                severity: 'danger',
                message: `效率 ${(currentEfficiency * 100).toFixed(1)}% 低于阈值`
            });
        }
        
        // 步数检查
        if (loop.step > this.thresholds.maxSteps) {
            warnings.push({
                type: 'TOO_MANY_STEPS',
                severity: 'warning',
                message: `循环步数 ${loop.step} 超过建议值`
            });
        }
        
        // 检测死亡螺旋
        if (loop.currentAmount < loop.initialAmount * 0.8) {
            warnings.push({
                type: 'DEATH_SPIRAL',
                severity: 'critical',
                message: `检测到死亡螺旋！资金已缩水 ${((1 - loop.currentAmount / loop.initialAmount) * 100).toFixed(1)}%`
            });
        }
        
        if (warnings.length > 0) {
            this.triggerAlert({
                loopId: loop.id,
                warnings,
                timestamp: Date.now()
            });
        }
    }
    
    // 触发警报
    triggerAlert(alert) {
        this.alerts.push(alert);
        
        const criticalAlerts = alert.warnings.filter(w => w.severity === 'critical');
        if (criticalAlerts.length > 0) {
            console.log(`[致命警报] 循环 #${alert.loopId}:`, criticalAlerts[0].message);
        }
        
        const warningAlerts = alert.warnings.filter(w => w.severity === 'warning');
        if (warningAlerts.length > 0) {
            console.log(`[警告] 循环 #${alert.loopId}:`, warningAlerts[0].message);
        }
    }
    
    // 生成循环报告
    generateLoopReport(loopId) {
        const loop = this.activeLoops.get(loopId) || 
                    this.completedLoops.find(l => l.id === loopId);
        if (!loop) return null;
        
        return {
            loopId: loop.id,
            status: loop.isComplete ? '已完成' : '进行中',
            progress: `${loop.step}/${loop.totalSteps}`,
            initialAmount: loop.initialAmount,
            currentAmount: loop.currentAmount,
            feesPaid: loop.feesPaid,
            yieldEarned: loop.yieldEarned,
            netReturn: loop.currentAmount - loop.initialAmount,
            efficiency: loop.yieldEarned > 0 
                ? (loop.currentAmount - loop.initialAmount) / loop.yieldEarned 
                : 0,
            duration: loop.endTime 
                ? (loop.endTime - loop.startTime) / 1000 
                : (Date.now() - loop.startTime) / 1000,
            history: loop.history
        };
    }
    
    // 获取统计概览
    getOverview() {
        return {
            activeLoops: this.activeLoops.size,
            completedLoops: this.completedLoops.length,
            totalAlerts: this.alerts.length,
            criticalAlerts: this.alerts.filter(a => 
                a.warnings.some(w => w.severity === 'critical')
            ).length,
            avgEfficiency: this.completedLoops.length > 0
                ? this.completedLoops.reduce((sum, l) => sum + l.efficiency, 0) / this.completedLoops.length
                : 0,
            totalVolume: [...this.activeLoops.values(), ...this.completedLoops]
                .reduce((sum, l) => sum + l.initialAmount, 0)
        };
    }
}

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

// 模拟循环监控
setInterval(() => {
    const loopId = Math.floor(Math.random() * 1000);
    const loop = monitor.monitorLoop({
        loopId,
        user: `0xuser${loopId}`,
        amount: Math.random() * 100 + 10,
        steps: Math.floor(Math.random() * 8) + 3
    });
    
    // 模拟步骤更新
    for (let i = 1; i <= loop.totalSteps; i++) {
        const stepData = {
            step: i,
            amount: loop.currentAmount * (1 + Math.random() * 0.02 - Math.random() * 0.015),
            fee: loop.currentAmount * 0.003,
            yield: loop.currentAmount * Math.random() * 0.015
        };
        monitor.updateLoopStep(loopId, stepData);
    }
    
    const result = monitor.completeLoop(loopId);
    console.log(`循环 #${loopId}: 净收益 $${result.netReturn.toFixed(2)}, 效率 ${(result.efficiency * 100).toFixed(1)}%`);
}, 3000);