013_跨链桥安全：连接区块链世界的风险与防护技术详解

跨链桥发展时间线：
2017年 - Wrapped Bitcoin (WBTC)出现，首个主流跨链资产
2020年 - Polkadot和Cosmos生态系统推出跨链通信协议
2021年 - Wormhole、Multichain（原AnySwap）等跨链桥快速发展
2022年 - Ronin桥黑客事件，损失6.25亿美元，创历史记录
2023年 - 跨链桥安全审计标准逐渐形成，MPC技术应用增加
2024-2025年 - 新一代安全跨链方案如光子桥、LayerZero兴起

锁定-铸造工作原理：
1. 用户在源链上将原生资产发送到桥合约指定地址（锁定）
2. 跨链桥验证锁定交易并确认
3. 验证者或智能合约在目标链上铸造对应的包装资产（铸造）
4. 用户在目标链上收到包装资产
5. 当用户希望将资产转回源链时，执行相反操作：销毁包装资产并解锁原生资产

// 源链上的锁定合约简化实现
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract SourceBridge is Ownable {
    // 原生代币地址
    address public nativeToken;
    // 验证者地址集合
    mapping(address => bool) public validators;
    // 所需的最小验证者数量
    uint256 public requiredValidations;
    // 已处理的交易ID
    mapping(bytes32 => bool) public processedTransactions;
    
    // 事件定义
    event TokensLocked(address indexed user, uint256 amount, bytes32 indexed transactionId, address targetChain);
    event ValidatorsUpdated();
    
    constructor(address _nativeToken, uint256 _requiredValidations) {
        nativeToken = _nativeToken;
        requiredValidations = _requiredValidations;
    }
    
    // 设置验证者
    function setValidators(address[] calldata _validators, bool[] calldata _statuses) external onlyOwner {
        require(_validators.length == _statuses.length, "Arrays length mismatch");
        
        for (uint i = 0; i < _validators.length; i++) {
            validators[_validators[i]] = _statuses[i];
        }
        
        emit ValidatorsUpdated();
    }
    
    // 锁定代币并发起跨链请求
    function lockTokens(uint256 amount, address targetUser, string calldata targetChain) external returns (bytes32) {
        // 验证金额
        require(amount > 0, "Amount must be greater than 0");
        
        // 生成唯一交易ID
        bytes32 transactionId = keccak256(abi.encodePacked(msg.sender, amount, block.timestamp, targetUser, targetChain));
        
        // 检查交易是否已处理
        require(!processedTransactions[transactionId], "Transaction already processed");
        
        // 锁定代币
        bool success = IERC20(nativeToken).transferFrom(msg.sender, address(this), amount);
        require(success, "Token transfer failed");
        
        // 标记交易为已处理
        processedTransactions[transactionId] = true;
        
        // 触发锁定事件，验证者将监听此事件
        emit TokensLocked(msg.sender, amount, transactionId, targetChain);
        
        return transactionId;
    }
    
    // 解锁代币（当用户从目标链返回时）
    function unlockTokens(address user, uint256 amount, bytes32 transactionId) external {
        // 验证调用者是授权的验证者
        require(validators[msg.sender], "Not authorized validator");
        
        // 检查交易是否已处理
        require(!processedTransactions[transactionId], "Transaction already processed");
        
        // 标记交易为已处理
        processedTransactions[transactionId] = true;
        
        // 解锁代币
        bool success = IERC20(nativeToken).transfer(user, amount);
        require(success, "Token transfer failed");
    }
}

// 目标链上的铸造合约简化实现
contract DestinationBridge is Ownable {
    // 包装代币合约
    address public wrappedToken;
    // 验证者地址集合
    mapping(address => bool) public validators;
    // 所需的最小验证者数量
    uint256 public requiredValidations;
    // 已处理的交易ID
    mapping(bytes32 => bool) public processedTransactions;
    // 每个交易的验证计数
    mapping(bytes32 => uint256) public validationCounts;
    // 已验证的交易
    mapping(bytes32 => mapping(address => bool)) public hasValidatorSigned;
    
    // 事件定义
    event TokensMinted(address indexed user, uint256 amount, bytes32 indexed transactionId);
    event TokensBurned(address indexed user, uint256 amount, bytes32 indexed transactionId);
    event ValidatorsUpdated();
    
    constructor(address _wrappedToken, uint256 _requiredValidations) {
        wrappedToken = _wrappedToken;
        requiredValidations = _requiredValidations;
    }
    
    // 设置验证者
    function setValidators(address[] calldata _validators, bool[] calldata _statuses) external onlyOwner {
        require(_validators.length == _statuses.length, "Arrays length mismatch");
        
        for (uint i = 0; i < _validators.length; i++) {
            validators[_validators[i]] = _statuses[i];
        }
        
        emit ValidatorsUpdated();
    }
    
    // 验证者提交验证
    function submitValidation(address user, uint256 amount, bytes32 transactionId) external {
        // 验证调用者是授权的验证者
        require(validators[msg.sender], "Not authorized validator");
        
        // 检查验证者是否已为此交易签名
        require(!hasValidatorSigned[transactionId][msg.sender], "Already validated");
        
        // 如果交易已处理，直接返回
        if (processedTransactions[transactionId]) {
            return;
        }
        
        // 记录验证者的验证
        hasValidatorSigned[transactionId][msg.sender] = true;
        validationCounts[transactionId]++;
        
        // 检查是否达到所需的验证数量
        if (validationCounts[transactionId] >= requiredValidations) {
            // 标记交易为已处理
            processedTransactions[transactionId] = true;
            
            // 铸造代币给用户
            bool success = ERC20Burnable(wrappedToken).mint(user, amount);
            require(success, "Token minting failed");
            
            emit TokensMinted(user, amount, transactionId);
        }
    }
    
    // 销毁代币并准备返回源链
    function burnTokens(uint256 amount, address sourceUser, string calldata sourceChain) external returns (bytes32) {
        // 验证金额
        require(amount > 0, "Amount must be greater than 0");
        
        // 生成唯一交易ID
        bytes32 transactionId = keccak256(abi.encodePacked(msg.sender, amount, block.timestamp, sourceUser, sourceChain));
        
        // 检查交易是否已处理
        require(!processedTransactions[transactionId], "Transaction already processed");
        
        // 销毁代币
        ERC20Burnable(wrappedToken).burnFrom(msg.sender, amount);
        
        // 标记交易为已处理
        processedTransactions[transactionId] = true;
        
        // 触发销毁事件，验证者将监听此事件以在源链上解锁
        emit TokensBurned(msg.sender, amount, transactionId);
        
        return transactionId;
    }
}

流动性网络工作原理：
1. 流动性提供者在不同链上的桥接合约中锁定资产提供流动性
2. 用户在源链上发送资产到本地桥接合约
3. 桥接合约从流动性池中扣除相应金额
4. 在目标链上，用户从本地桥接合约的流动性池中提取资产
5. 流动性提供者通过跨链套利和费用获得收益
6. 流动性网络定期重新平衡不同链上的流动性

// 跨链流动性网络简化实现
class LiquidityBridge {
  constructor() {
    // 链上流动性池
    this.liquidityPools = new Map();
    // 流动性提供者记录
    this.liquidityProviders = new Map();
    // 交易记录
    this.transactions = new Map();
    // 跨链手续费（百分比）
    this.bridgeFee = 0.001;
    // 最小流动性要求
    this.minLiquidity = 1000;
    // 跨链确认时间（秒）
    this.confirmationTime = 120;
    // 流动性提供者奖励比例
    this.providerRewardShare = 0.7;
  }
  
  // 初始化特定链的流动性池
  initializeChain(chainId, tokenAddress) {
    if (!this.liquidityPools.has(chainId)) {
      this.liquidityPools.set(chainId, {
        tokenAddress,
        totalLiquidity: 0,
        pendingWithdrawals: new Map(),
        lastRebalanced: Date.now()
      });
      console.log(`Initialized liquidity pool for chain ${chainId}`);
    }
  }
  
  // 添加流动性
  addLiquidity(provider, chainId, amount) {
    // 检查链是否初始化
    if (!this.liquidityPools.has(chainId)) {
      throw new Error(`Chain ${chainId} not initialized`);
    }
    
    const pool = this.liquidityPools.get(chainId);
    
    // 检查提供者记录
    if (!this.liquidityProviders.has(provider)) {
      this.liquidityProviders.set(provider, new Map());
    }
    
    const providerData = this.liquidityProviders.get(provider);
    if (!providerData.has(chainId)) {
      providerData.set(chainId, 0);
    }
    
    // 更新流动性
    providerData.set(chainId, providerData.get(chainId) + amount);
    pool.totalLiquidity += amount;
    
    console.log(`Provider ${provider} added ${amount} liquidity to chain ${chainId}`);
    console.log(`Total liquidity on chain ${chainId}: ${pool.totalLiquidity}`);
    
    return {
      success: true,
      newProviderBalance: providerData.get(chainId),
      totalLiquidity: pool.totalLiquidity
    };
  }
  
  // 移除流动性
  removeLiquidity(provider, chainId, amount) {
    // 检查链是否初始化
    if (!this.liquidityPools.has(chainId)) {
      throw new Error(`Chain ${chainId} not initialized`);
    }
    
    const pool = this.liquidityPools.get(chainId);
    
    // 检查提供者记录
    if (!this.liquidityProviders.has(provider) || !this.liquidityProviders.get(provider).has(chainId)) {
      throw new Error(`No liquidity provided for chain ${chainId}`);
    }
    
    const providerData = this.liquidityProviders.get(provider);
    const providerLiquidity = providerData.get(chainId);
    
    // 检查流动性是否足够
    if (amount > providerLiquidity) {
      throw new Error(`Insufficient liquidity to remove: ${amount} requested, ${providerLiquidity} available`);
    }
    
    // 检查池流动性是否足够
    if (amount > pool.totalLiquidity) {
      throw new Error(`Insufficient pool liquidity`);
    }
    
    // 更新流动性
    providerData.set(chainId, providerLiquidity - amount);
    pool.totalLiquidity -= amount;
    
    console.log(`Provider ${provider} removed ${amount} liquidity from chain ${chainId}`);
    console.log(`Total liquidity on chain ${chainId}: ${pool.totalLiquidity}`);
    
    return {
      success: true,
      remainingProviderBalance: providerData.get(chainId),
      totalLiquidity: pool.totalLiquidity
    };
  }
  
  // 发起跨链交易
  initiateBridgeTransaction(user, sourceChain, destinationChain, amount) {
    // 检查链是否初始化
    if (!this.liquidityPools.has(sourceChain) || !this.liquidityPools.has(destinationChain)) {
      throw new Error(`One or both chains not initialized`);
    }
    
    const sourcePool = this.liquidityPools.get(sourceChain);
    
    // 检查源链流动性
    if (amount > sourcePool.totalLiquidity) {
      throw new Error(`Insufficient liquidity on source chain`);
    }
    
    // 计算费用
    const fee = amount * this.bridgeFee;
    const netAmount = amount - fee;
    
    // 生成交易ID
    const txId = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    
    // 记录交易
    this.transactions.set(txId, {
      user,
      sourceChain,
      destinationChain,
      amount,
      netAmount,
      fee,
      status: 'initiated',
      initiatedAt: Date.now(),
      expiresAt: Date.now() + this.confirmationTime * 1000,
      claimed: false
    });
    
    // 从源池扣除金额
    sourcePool.totalLiquidity -= amount;
    
    console.log(`Transaction ${txId} initiated: ${amount} from chain ${sourceChain} to ${destinationChain}`);
    console.log(`Fee: ${fee}, Net amount: ${netAmount}`);
    
    // 模拟跨链消息传递
    this.simulateCrossChainMessage(txId);
    
    return {
      success: true,
      txId,
      fee,
      netAmount,
      expiresAt: new Date(Date.now() + this.confirmationTime * 1000)
    };
  }
  
  // 模拟跨链消息传递
  async simulateCrossChainMessage(txId) {
    // 在实际应用中，这里会通过跨链消息协议发送消息
    // 这里我们简单地延迟一段时间后将交易状态更新为可提取
    
    setTimeout(() => {
      if (this.transactions.has(txId)) {
        const tx = this.transactions.get(txId);
        if (tx.status === 'initiated' && Date.now() < tx.expiresAt) {
          tx.status = 'claimable';
          console.log(`Transaction ${txId} is now claimable on chain ${tx.destinationChain}`);
        }
      }
    }, this.confirmationTime * 1000);
  }
  
  // 提取跨链资产
  claimBridgeAssets(user, txId) {
    // 检查交易是否存在
    if (!this.transactions.has(txId)) {
      throw new Error(`Transaction ${txId} not found`);
    }
    
    const tx = this.transactions.get(txId);
    
    // 验证用户
    if (tx.user !== user) {
      throw new Error(`Not authorized to claim this transaction`);
    }
    
    // 检查交易状态
    if (tx.status !== 'claimable') {
      throw new Error(`Transaction not ready for claiming`);
    }
    
    // 检查是否已过期
    if (Date.now() > tx.expiresAt) {
      throw new Error(`Transaction has expired`);
    }
    
    // 检查是否已提取
    if (tx.claimed) {
      throw new Error(`Transaction already claimed`);
    }
    
    const destinationPool = this.liquidityPools.get(tx.destinationChain);
    
    // 检查目标池流动性
    if (tx.netAmount > destinationPool.totalLiquidity) {
      throw new Error(`Insufficient liquidity on destination chain`);
    }
    
    // 从目标池扣除净额
    destinationPool.totalLiquidity -= tx.netAmount;
    
    // 更新交易状态
    tx.status = 'completed';
    tx.claimed = true;
    tx.claimedAt = Date.now();
    
    console.log(`Transaction ${txId} completed: ${tx.netAmount} claimed on chain ${tx.destinationChain}`);
    
    // 分配费用给流动性提供者
    this.distributeFees(tx.fee, tx.sourceChain, tx.destinationChain);
    
    return {
      success: true,
      amountClaimed: tx.netAmount,
      timestamp: tx.claimedAt
    };
  }
  
  // 分配费用给流动性提供者
  distributeFees(fee, sourceChain, destinationChain) {
    // 计算分配给提供者的奖励
    const providerReward = fee * this.providerRewardShare;
    
    // 获取相关链上的提供者
    const allProviders = this.liquidityProviders;
    let totalEligibleLiquidity = 0;
    
    // 计算总合格流动性
    for (const [provider, chains] of allProviders.entries()) {
      if (chains.has(sourceChain)) {
        totalEligibleLiquidity += chains.get(sourceChain);
      }
      if (chains.has(destinationChain)) {
        totalEligibleLiquidity += chains.get(destinationChain);
      }
    }
    
    if (totalEligibleLiquidity > 0) {
      // 按比例分配奖励
      for (const [provider, chains] of allProviders.entries()) {
        let providerShare = 0;
        
        if (chains.has(sourceChain)) {
          const sourceLiquidity = chains.get(sourceChain);
          providerShare += (sourceLiquidity / totalEligibleLiquidity) * providerReward;
        }
        
        if (chains.has(destinationChain)) {
          const destLiquidity = chains.get(destinationChain);
          providerShare += (destLiquidity / totalEligibleLiquidity) * providerReward;
        }
        
        if (providerShare > 0) {
          console.log(`Distributed ${providerShare} reward to provider ${provider}`);
          // 在实际应用中，这里会将奖励添加到提供者的余额中
        }
      }
    }
  }
  
  // 重新平衡跨链流动性
  rebalanceLiquidity(sourceChain, destinationChain, amount) {
    // 检查链是否初始化
    if (!this.liquidityPools.has(sourceChain) || !this.liquidityPools.has(destinationChain)) {
      throw new Error(`One or both chains not initialized`);
    }
    
    const sourcePool = this.liquidityPools.get(sourceChain);
    const destPool = this.liquidityPools.get(destinationChain);
    
    // 检查源池流动性
    if (amount > sourcePool.totalLiquidity) {
      throw new Error(`Insufficient liquidity on source chain for rebalancing`);
    }
    
    // 更新流动性
    sourcePool.totalLiquidity -= amount;
    destPool.totalLiquidity += amount;
    destPool.lastRebalanced = Date.now();
    
    console.log(`Rebalanced ${amount} liquidity from chain ${sourceChain} to ${destinationChain}`);
    console.log(`New liquidity on ${sourceChain}: ${sourcePool.totalLiquidity}`);
    console.log(`New liquidity on ${destinationChain}: ${destPool.totalLiquidity}`);
    
    return {
      success: true,
      sourceChainLiquidity: sourcePool.totalLiquidity,
      destinationChainLiquidity: destPool.totalLiquidity,
      timestamp: Date.now()
    };
  }
  
  // 获取池状态
  getPoolStatus(chainId) {
    if (!this.liquidityPools.has(chainId)) {
      throw new Error(`Chain ${chainId} not initialized`);
    }
    
    const pool = this.liquidityPools.get(chainId);
    return {
      chainId,
      tokenAddress: pool.tokenAddress,
      totalLiquidity: pool.totalLiquidity,
      minLiquidity: this.minLiquidity,
      isLiquiditySufficient: pool.totalLiquidity >= this.minLiquidity,
      lastRebalanced: new Date(pool.lastRebalanced)
    };
  }
  
  // 获取交易状态
  getTransactionStatus(txId) {
    if (!this.transactions.has(txId)) {
      throw new Error(`Transaction ${txId} not found`);
    }
    
    const tx = this.transactions.get(txId);
    return {
      txId,
      user: tx.user,
      sourceChain: tx.sourceChain,
      destinationChain: tx.destinationChain,
      amount: tx.amount,
      fee: tx.fee,
      netAmount: tx.netAmount,
      status: tx.status,
      initiatedAt: new Date(tx.initiatedAt),
      expiresAt: new Date(tx.expiresAt),
      claimed: tx.claimed,
      claimedAt: tx.claimedAt ? new Date(tx.claimedAt) : null
    };
  }
}

// 使用示例
function exampleUsage() {
  const bridge = new LiquidityBridge();
  
  try {
    // 初始化链
    bridge.initializeChain('ethereum', '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'); // USDC
    bridge.initializeChain('polygon', '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'); // USDC
    bridge.initializeChain('avalanche', '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E'); // USDC
    
    // 添加流动性
    bridge.addLiquidity('provider1', 'ethereum', 5000);
    bridge.addLiquidity('provider1', 'polygon', 3000);
    bridge.addLiquidity('provider2', 'polygon', 4000);
    bridge.addLiquidity('provider2', 'avalanche', 6000);
    
    // 显示池状态
    console.log('\nPool Status - Ethereum:', bridge.getPoolStatus('ethereum'));
    console.log('Pool Status - Polygon:', bridge.getPoolStatus('polygon'));
    
    // 发起跨链交易
    const txResult = bridge.initiateBridgeTransaction('user123', 'ethereum', 'polygon', 1000);
    console.log('\nBridge Transaction:', txResult);
    
    // 模拟时间流逝
    console.log('\nWaiting for cross-chain confirmation...');
    
    // 2分钟后提取（模拟）
    setTimeout(() => {
      try {
        const claimResult = bridge.claimBridgeAssets('user123', txResult.txId);
        console.log('\nClaim Result:', claimResult);
        
        // 显示更新后的池状态
        console.log('\nUpdated Pool Status - Ethereum:', bridge.getPoolStatus('ethereum'));
        console.log('Updated Pool Status - Polygon:', bridge.getPoolStatus('polygon'));
        
        // 重新平衡流动性
        console.log('\nRebalancing liquidity...');
        bridge.rebalanceLiquidity('avalanche', 'ethereum', 2000);
        
        // 显示重新平衡后的状态
        console.log('\nFinal Pool Status - Ethereum:', bridge.getPoolStatus('ethereum'));
        console.log('Final Pool Status - Avalanche:', bridge.getPoolStatus('avalanche'));
        
      } catch (error) {
        console.error('Claim failed:', error);
      }
    }, 125000); // 125秒，略多于确认时间
    
  } catch (error) {
    console.error('Error:', error);
  }
}

// 运行示例
exampleUsage();

HTLC工作原理：
1. 发送方在源链上创建HTLC，存入资产并设置哈希锁和时间锁
2. 发送方将哈希原像秘密传递给接收方
3. 接收方在目标链上使用哈希原像解锁资产
4. 如果接收方未能在时间锁过期前解锁，发送方可以取回资产
5. 整个过程无需信任第三方验证者

// 多签验证系统简化实现
class MultiSignatureValidator {
  constructor(requiredSignatures, timeout = 3600000) {
    // 所需的最小签名数量
    this.requiredSignatures = requiredSignatures;
    // 交易超时时间（毫秒）
    this.timeout = timeout;
    // 验证者集合
    this.validators = new Map();
    // 交易签名记录
    this.transactionSignatures = new Map();
    // 已执行的交易
    this.executedTransactions = new Set();
    // 待处理的交易
    this.pendingTransactions = new Map();
  }
  
  // 添加验证者
  addValidator(validatorAddress, publicKey) {
    if (this.validators.has(validatorAddress)) {
      throw new Error('Validator already exists');
    }
    
    this.validators.set(validatorAddress, {
      publicKey,
      active: true,
      joinedAt: Date.now()
    });
    
    console.log(`Added validator: ${validatorAddress}`);
    return true;
  }
  
  // 移除验证者
  removeValidator(validatorAddress) {
    if (!this.validators.has(validatorAddress)) {
      throw new Error('Validator not found');
    }
    
    this.validators.delete(validatorAddress);
    console.log(`Removed validator: ${validatorAddress}`);
    return true;
  }
  
  // 暂停/恢复验证者
  setValidatorStatus(validatorAddress, active) {
    if (!this.validators.has(validatorAddress)) {
      throw new Error('Validator not found');
    }
    
    const validator = this.validators.get(validatorAddress);
    validator.active = active;
    
    console.log(`Set validator ${validatorAddress} status to ${active ? 'active' : 'inactive'}`);
    return true;
  }
  
  // 创建新的交易
  createTransaction(txData) {
    // 生成交易ID
    const txId = this.generateTransactionId(txData);
    
    // 检查交易是否已存在
    if (this.pendingTransactions.has(txId) || this.executedTransactions.has(txId)) {
      throw new Error('Transaction already exists');
    }
    
    // 创建交易记录
    this.pendingTransactions.set(txId, {
      id: txId,
      data: txData,
      createdAt: Date.now(),
      expiresAt: Date.now() + this.timeout,
      signatures: new Map(),
      executed: false
    });
    
    // 初始化签名记录
    this.transactionSignatures.set(txId, new Map());
    
    console.log(`Created new transaction: ${txId}`);
    
    return txId;
  }
  
  // 验证者提交签名
  submitSignature(validatorAddress, txId, signature) {
    // 验证验证者是否存在且活跃
    if (!this.validators.has(validatorAddress) || !this.validators.get(validatorAddress).active) {
      throw new Error('Invalid or inactive validator');
    }
    
    // 验证交易是否存在
    if (!this.pendingTransactions.has(txId)) {
      throw new Error('Transaction not found');
    }
    
    const transaction = this.pendingTransactions.get(txId);
    
    // 检查交易是否已执行
    if (transaction.executed || this.executedTransactions.has(txId)) {
      throw new Error('Transaction already executed');
    }
    
    // 检查交易是否已过期
    if (Date.now() > transaction.expiresAt) {
      throw new Error('Transaction expired');
    }
    
    // 检查验证者是否已签名
    if (transaction.signatures.has(validatorAddress)) {
      throw new Error('Validator already signed this transaction');
    }
    
    // 验证签名（在实际应用中，这里应该有真正的签名验证逻辑）
    const isValidSignature = this.verifySignature(validatorAddress, txId, transaction.data, signature);
    
    if (!isValidSignature) {
      throw new Error('Invalid signature');
    }
    
    // 记录签名
    transaction.signatures.set(validatorAddress, signature);
    
    console.log(`Validator ${validatorAddress} signed transaction ${txId}`);
    console.log(`Current signatures: ${transaction.signatures.size}/${this.requiredSignatures}`);
    
    // 检查是否达到所需签名数量
    if (transaction.signatures.size >= this.requiredSignatures) {
      // 执行交易
      return this.executeTransaction(txId);
    }
    
    return {
      success: true,
      txId,
      signaturesReceived: transaction.signatures.size,
      signaturesRequired: this.requiredSignatures,
      executed: false
    };
  }
  
  // 执行交易
  executeTransaction(txId) {
    // 检查交易是否存在
    if (!this.pendingTransactions.has(txId)) {
      throw new Error('Transaction not found');
    }
    
    const transaction = this.pendingTransactions.get(txId);
    
    // 检查交易是否已执行
    if (transaction.executed || this.executedTransactions.has(txId)) {
      throw new Error('Transaction already executed');
    }
    
    // 检查交易是否已过期
    if (Date.now() > transaction.expiresAt) {
      throw new Error('Transaction expired');
    }
    
    // 检查签名数量
    if (transaction.signatures.size < this.requiredSignatures) {
      throw new Error('Not enough signatures to execute');
    }
    
    // 标记交易为已执行
    transaction.executed = true;
    transaction.executedAt = Date.now();
    this.executedTransactions.add(txId);
    
    // 模拟交易执行
    console.log(`Executing transaction ${txId} with ${transaction.signatures.size} signatures`);
    console.log('Transaction data:', transaction.data);
    
    // 在实际应用中，这里会调用相应的执行逻辑，如铸造代币、解锁资产等
    
    return {
      success: true,
      txId,
      executedAt: transaction.executedAt,
      signatures: Array.from(transaction.signatures.keys())
    };
  }
  
  // 取消过期交易
  cancelExpiredTransaction(txId) {
    // 检查交易是否存在
    if (!this.pendingTransactions.has(txId)) {
      throw new Error('Transaction not found');
    }
    
    const transaction = this.pendingTransactions.get(txId);
    
    // 检查交易是否已执行
    if (transaction.executed || this.executedTransactions.has(txId)) {
      throw new Error('Cannot cancel executed transaction');
    }
    
    // 检查交易是否已过期
    if (Date.now() <= transaction.expiresAt) {
      throw new Error('Transaction has not expired yet');
    }
    
    // 删除交易
    this.pendingTransactions.delete(txId);
    this.transactionSignatures.delete(txId);
    
    console.log(`Canceled expired transaction: ${txId}`);
    
    return {
      success: true,
      txId,
      reason: 'Transaction expired'
    };
  }
  
  // 获取交易状态
  getTransactionStatus(txId) {
    // 检查已执行的交易
    if (this.executedTransactions.has(txId)) {
      // 查找交易记录（在实际应用中，可能需要从历史记录中获取）
      if (this.pendingTransactions.has(txId)) {
        const tx = this.pendingTransactions.get(txId);
        return {
          txId,
          status: 'executed',
          executedAt: tx.executedAt,
          signaturesReceived: tx.signatures.size,
          signaturesRequired: this.requiredSignatures,
          signers: Array.from(tx.signatures.keys())
        };
      }
      
      return {
        txId,
        status: 'executed',
        signaturesRequired: this.requiredSignatures
      };
    }
    
    // 检查待处理的交易
    if (this.pendingTransactions.has(txId)) {
      const tx = this.pendingTransactions.get(txId);
      const isExpired = Date.now() > tx.expiresAt;
      
      return {
        txId,
        status: isExpired ? 'expired' : 'pending',
        createdAt: tx.createdAt,
        expiresAt: tx.expiresAt,
        signaturesReceived: tx.signatures.size,
        signaturesRequired: this.requiredSignatures,
        signers: Array.from(tx.signatures.keys()),
        expired: isExpired
      };
    }
    
    return {
      txId,
      status: 'not_found'
    };
  }
  
  // 获取验证者状态
  getValidatorStatus(validatorAddress) {
    if (!this.validators.has(validatorAddress)) {
      return { exists: false };
    }
    
    const validator = this.validators.get(validatorAddress);
    return {
      exists: true,
      active: validator.active,
      joinedAt: validator.joinedAt,
      publicKey: validator.publicKey
    };
  }
  
  // 生成交易ID（简化版）
  generateTransactionId(txData) {
    // 在实际应用中，这里应该有更安全的ID生成机制
    const dataStr = JSON.stringify(txData);
    return `tx_${Date.now()}_${Math.abs(dataStr.split('').reduce((acc, char) => {
      acc = ((acc << 5) - acc) + char.charCodeAt(0);
      return acc & acc;
    }, 0))}`;
  }
  
  // 验证签名（简化版）
  verifySignature(validatorAddress, txId, txData, signature) {
    // 在实际应用中，这里应该使用密码学库验证签名
    // 这里我们简单模拟验证过程
    console.log(`Verifying signature for validator ${validatorAddress} on transaction ${txId}`);
    return signature && signature.length > 0;
  }
}

// 使用示例
function exampleUsage() {
  // 创建一个需要3个签名的多签验证器
  const multisig = new MultiSignatureValidator(3, 60000); // 3个签名，超时60秒
  
  try {
    // 添加验证者
    multisig.addValidator('validator1', 'pubkey1');
    multisig.addValidator('validator2', 'pubkey2');
    multisig.addValidator('validator3', 'pubkey3');
    multisig.addValidator('validator4', 'pubkey4');
    
    // 创建跨链交易
    const txData = {
      sourceChain: 'ethereum',
      destinationChain: 'polygon',
      user: 'user123',
      amount: 1000,
      token: 'USDC',
      sourceTxHash: '0x123...'
    };
    
    const txId = multisig.createTransaction(txData);
    
    // 验证者提交签名
    console.log('\nValidator 1 signing...');
    multisig.submitSignature('validator1', txId, 'signature1');
    
    console.log('\nValidator 2 signing...');
    multisig.submitSignature('validator2', txId, 'signature2');
    
    console.log('\nValidator 3 signing (this should execute the transaction)...');
    const result = multisig.submitSignature('validator3', txId, 'signature3');
    console.log('\nTransaction execution result:', result);
    
    // 尝试再次签名已执行的交易
    try {
      console.log('\nTrying to sign executed transaction...');
      multisig.submitSignature('validator4', txId, 'signature4');
    } catch (error) {
      console.log('Expected error:', error.message);
    }
    
    // 创建新交易但不完成签名，等待过期
    const txId2 = multisig.createTransaction({
      ...txData,
      amount: 2000,
      sourceTxHash: '0x456...'
    });
    
    console.log('\nCreated second transaction:', txId2);
    console.log('\nValidator 1 signing second transaction...');
    multisig.submitSignature('validator1', txId2, 'signature1_2');
    
    // 模拟时间流逝
    console.log('\nWaiting for transaction to expire...');
    setTimeout(() => {
      try {
        // 尝试取消过期交易
        console.log('\nCanceling expired transaction...');
        const cancelResult = multisig.cancelExpiredTransaction(txId2);
        console.log('Cancel result:', cancelResult);
        
        // 检查交易状态
        console.log('\nFinal transaction status:', multisig.getTransactionStatus(txId2));
        
      } catch (error) {
        console.error('Cancel failed:', error);
      }
    }, 65000); // 65秒，略多于过期时间
    
  } catch (error) {
    console.error('Error:', error);
  }
}

// 运行示例
exampleUsage();

零知识证明验证工作原理：
1. 源链上发生交易后，生成关于该交易的零知识证明
2. 证明包含交易的有效性但不泄露具体细节
3. 目标链上的合约验证零知识证明
4. 验证通过后，在目标链上执行相应操作
5. 整个过程无需信任第三方，安全性基于密码学

状态证明验证工作原理：
1. 验证者生成源链状态的密码学证明
2. 证明包含交易的有效性和状态转换的正确性
3. 目标链上的智能合约验证这些证明
4. 验证通过后，执行相应的资产转移
5. 提供更高的安全性，但计算复杂度较高

中继者工作流程：
1. 监听源链上的事件
2. 验证事件的有效性
3. 将消息格式化为目标链可接受的格式
4. 将消息发送到目标链上的合约
5. 目标链合约验证消息并执行相应操作

预言机跨链工作流程：
1. 源链上的智能合约请求数据或事件传递
2. 多个预言机节点监听并验证请求
3. 预言机节点将数据或事件发送到目标链
4. 目标链上的合约验证多个预言机的响应
5. 通过多数投票机制确定消息的真实性

1. 攻击者获得了验证者节点的访问权限
2. 控制了5/9的验证节点，超过了所需的阈值
3. 伪造了跨链交易，将大量ETH和USDC转移到攻击者地址
4. 攻击过程中没有触发任何安全警报

1. 攻击者发现了合约中的验证逻辑漏洞
2. 利用漏洞在以太坊上铸造了大量包装的Solana代币
3. 绕过了验证机制，没有在Solana上锁定相应资产
4. 利用铸造的代币在DEX上快速兑换为其他资产

1. 攻击者可能获取了项目创始人的私钥
2. 利用私钥控制了跨链桥的关键功能
3. 执行了未授权的跨链转账
4. 由于私钥管理不当，攻击得以成功

跨链桥多层安全架构：
1. 密码学层：强大的加密算法和零知识证明
2. 共识层：健壮的验证者共识机制
3. 合约层：经过审计的智能合约
4. 监控层：实时交易监控和异常检测
5. 响应层：快速应急响应机制
6. 保险层：跨链资产保险覆盖

// 安全的跨链桥合约实现示例
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title SecureCrossChainBridge
 * @dev 安全的跨链桥实现，包含多层安全机制
 */
contract SecureCrossChainBridge is AccessControl, Pausable, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    
    // 角色定义
    bytes32 public constant VALIDATOR_ROLE = keccak256("VALIDATOR_ROLE");
    bytes32 public constant GOVERNANCE_ROLE = keccak256("GOVERNANCE_ROLE");
    bytes32 public constant EMERGENCY_ROLE = keccak256("EMERGENCY_ROLE");
    
    // 事件
    event TokensLocked(address indexed user, uint256 amount, bytes32 indexed transactionId, string targetChain);
    event TokensReleased(address indexed user, uint256 amount, bytes32 indexed transactionId);
    event SignatureSubmitted(address indexed validator, bytes32 indexed transactionId, uint256 signaturesCount);
    event TransactionExecuted(bytes32 indexed transactionId, address indexed user, uint256 amount);
    event TransactionCanceled(bytes32 indexed transactionId, string reason);
    event ValidatorThresholdUpdated(uint256 newThreshold);
    event BridgePaused(address indexed admin);
    event BridgeUnpaused(address indexed admin);
    event EmergencyWithdrawal(address indexed user, uint256 amount);
    
    // 配置参数
    uint256 public validatorThreshold;
    uint256 public transactionTimeout;
    uint256 public maxTransactionAmount;
    uint256 public dailyLimit;
    uint256 public dailyVolume;
    uint256 public lastResetTime;
    
    // 代币地址
    IERC20 public token;
    
    // 交易状态
    enum TransactionStatus { PENDING, CONFIRMED, EXECUTED, CANCELED, EXPIRED }
    
    // 交易结构
    struct Transaction {
        address user;
        uint256 amount;
        string sourceChain;
        string targetChain;
        uint256 timestamp;
        TransactionStatus status;
        mapping(address => bool) signatures;
        uint256 signaturesCount;
    }
    
    // 存储所有交易
    mapping(bytes32 => Transaction) public transactions;
    
    // 已处理的交易ID
    mapping(bytes32 => bool) public processedTransactionIds;
    
    // 用户锁定的总金额
    mapping(address => uint256) public userLockedAmounts;
    
    /**
     * @dev 构造函数
     */
    constructor(
        address _token,
        uint256 _validatorThreshold,
        uint256 _transactionTimeout,
        uint256 _maxTransactionAmount,
        uint256 _dailyLimit
    ) {
        require(_token != address(0), "Invalid token address");
        require(_validatorThreshold > 0, "Validator threshold must be greater than 0");
        require(_transactionTimeout > 0, "Transaction timeout must be greater than 0");
        require(_maxTransactionAmount > 0, "Max transaction amount must be greater than 0");
        require(_dailyLimit > 0, "Daily limit must be greater than 0");
        
        token = IERC20(_token);
        validatorThreshold = _validatorThreshold;
        transactionTimeout = _transactionTimeout;
        maxTransactionAmount = _maxTransactionAmount;
        dailyLimit = _dailyLimit;
        lastResetTime = block.timestamp;
        
        // 设置角色
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(GOVERNANCE_ROLE, msg.sender);
        _setupRole(EMERGENCY_ROLE, msg.sender);
    }
    
    /**
     * @dev 防止重入的修饰符
     */
    modifier nonReentrant() {
        _nonReentrant;
        _;
    }
    
    /**
     * @dev 检查交易状态的修饰符
     */
    modifier validTransactionState(bytes32 _transactionId, TransactionStatus _requiredStatus) {
        require(transactions[_transactionId].status == _requiredStatus, "Invalid transaction status");
        _;
    }
    
    /**
     * @dev 检查每日限额
     */
    modifier checkDailyLimit(uint256 _amount) {
        // 重置每日限额（如果需要）
        if (block.timestamp >= lastResetTime.add(24 hours)) {
            dailyVolume = 0;
            lastResetTime = block.timestamp;
        }
        
        require(dailyVolume.add(_amount) <= dailyLimit, "Daily limit exceeded");
        _;
    }
    
    /**
     * @dev 用户锁定代币以发起跨链交易
     */
    function lockTokens(
        uint256 _amount,
        string calldata _targetChain
    ) external whenNotPaused nonReentrant checkDailyLimit(_amount) returns (bytes32) {
        // 验证金额
        require(_amount > 0, "Amount must be greater than 0");
        require(_amount <= maxTransactionAmount, "Amount exceeds maximum transaction limit");
        
        // 生成交易ID
        bytes32 transactionId = keccak256(abi.encodePacked(
            msg.sender,
            _amount,
            block.timestamp,
            blockhash(block.number - 1),
            _targetChain
        ));
        
        // 确保交易ID唯一
        require(!processedTransactionIds[transactionId], "Transaction ID already exists");
        
        // 转移代币
        token.safeTransferFrom(msg.sender, address(this), _amount);
        
        // 创建交易记录
        Transaction storage newTransaction = transactions[transactionId];
        newTransaction.user = msg.sender;
        newTransaction.amount = _amount;
        newTransaction.sourceChain = "ethereum"; // 假设当前链是以太坊
        newTransaction.targetChain = _targetChain;
        newTransaction.timestamp = block.timestamp;
        newTransaction.status = TransactionStatus.PENDING;
        newTransaction.signaturesCount = 0;
        
        // 标记交易ID为已处理
        processedTransactionIds[transactionId] = true;
        
        // 更新用户锁定金额
        userLockedAmounts[msg.sender] = userLockedAmounts[msg.sender].add(_amount);
        
        // 更新每日交易量
        dailyVolume = dailyVolume.add(_amount);
        
        emit TokensLocked(msg.sender, _amount, transactionId, _targetChain);
        
        return transactionId;
    }
    
    /**
     * @dev 验证者提交签名
     */
    function submitSignature(bytes32 _transactionId) external onlyRole(VALIDATOR_ROLE) nonReentrant {
        Transaction storage transaction = transactions[_transactionId];
        
        // 检查交易是否存在且状态为PENDING
        require(transaction.status == TransactionStatus.PENDING, "Invalid transaction status");
        
        // 检查验证者是否已签名
        require(!transaction.signatures[msg.sender], "Validator already signed");
        
        // 记录签名
        transaction.signatures[msg.sender] = true;
        transaction.signaturesCount = transaction.signaturesCount.add(1);
        
        emit SignatureSubmitted(msg.sender, _transactionId, transaction.signaturesCount);
        
        // 检查是否达到验证阈值
        if (transaction.signaturesCount >= validatorThreshold) {
            // 更新交易状态
            transaction.status = TransactionStatus.CONFIRMED;
        }
    }
    
    /**
     * @dev 执行已确认的交易（在目标链上铸造代币）
     * 注意：在实际的跨链场景中，这部分逻辑会在目标链上执行
     */
    function executeTransaction(bytes32 _transactionId) external onlyRole(VALIDATOR_ROLE) nonReentrant {
        Transaction storage transaction = transactions[_transactionId];
        
        // 检查交易状态
        require(transaction.status == TransactionStatus.CONFIRMED, "Transaction not confirmed");
        
        // 更新交易状态
        transaction.status = TransactionStatus.EXECUTED;
        
        // 在实际场景中，这里会调用铸造函数或释放资金
        // 对于锁定-铸造模式，在目标链上铸造相应的代币
        
        emit TransactionExecuted(_transactionId, transaction.user, transaction.amount);
    }
    
    /**
     * @dev 取消过期交易
     */
    function cancelExpiredTransaction(bytes32 _transactionId) external nonReentrant {
        Transaction storage transaction = transactions[_transactionId];
        
        // 检查交易是否存在且状态为PENDING
        require(transaction.status == TransactionStatus.PENDING, "Invalid transaction status");
        
        // 检查交易是否过期
        require(block.timestamp >= transaction.timestamp.add(transactionTimeout), "Transaction not expired");
        
        // 只有用户或管理员可以取消过期交易
        require(
            msg.sender == transaction.user || 
            hasRole(GOVERNANCE_ROLE, msg.sender) || 
            hasRole(EMERGENCY_ROLE, msg.sender),
            "Not authorized to cancel"
        );
        
        // 更新交易状态
        transaction.status = TransactionStatus.EXPIRED;
        
        // 返还用户资金
        uint256 amount = transaction.amount;
        token.safeTransfer(transaction.user, amount);
        
        // 更新用户锁定金额
        userLockedAmounts[transaction.user] = userLockedAmounts[transaction.user].sub(amount);
        
        emit TransactionCanceled(_transactionId, "Transaction expired");
        emit TokensReleased(transaction.user, amount, _transactionId);
    }
    
    /**
     * @dev 紧急暂停桥接功能
     */
    function pause() external onlyRole(EMERGENCY_ROLE) {
        _pause();
        emit BridgePaused(msg.sender);
    }
    
    /**
     * @dev 恢复桥接功能
     */
    function unpause() external onlyRole(EMERGENCY_ROLE) {
        _unpause();
        emit BridgeUnpaused(msg.sender);
    }
    
    /**
     * @dev 紧急提款（在极端情况下）
     */
    function emergencyWithdraw(address _user) external onlyRole(EMERGENCY_ROLE) nonReentrant {
        uint256 amount = userLockedAmounts[_user];
        require(amount > 0, "No locked funds to withdraw");
        
        // 清零用户锁定金额
        userLockedAmounts[_user] = 0;
        
        // 转移资金
        token.safeTransfer(_user, amount);
        
        emit EmergencyWithdrawal(_user, amount);
    }
    
    /**
     * @dev 更新验证者阈值（治理功能）
     */
    function updateValidatorThreshold(uint256 _newThreshold) external onlyRole(GOVERNANCE_ROLE) {
        require(_newThreshold > 0, "Threshold must be greater than 0");
        validatorThreshold = _newThreshold;
        emit ValidatorThresholdUpdated(_newThreshold);
    }
    
    /**
     * @dev 更新交易超时时间（治理功能）
     */
    function updateTransactionTimeout(uint256 _newTimeout) external onlyRole(GOVERNANCE_ROLE) {
        require(_newTimeout > 0, "Timeout must be greater than 0");
        transactionTimeout = _newTimeout;
    }
    
    /**
     * @dev 更新最大交易金额（治理功能）
     */
    function updateMaxTransactionAmount(uint256 _newMaxAmount) external onlyRole(GOVERNANCE_ROLE) {
        require(_newMaxAmount > 0, "Max amount must be greater than 0");
        maxTransactionAmount = _newMaxAmount;
    }
    
    /**
     * @dev 更新每日限额（治理功能）
     */
    function updateDailyLimit(uint256 _newDailyLimit) external onlyRole(GOVERNANCE_ROLE) {
        require(_newDailyLimit > 0, "Daily limit must be greater than 0");
        dailyLimit = _newDailyLimit;
    }
    
    /**
     * @dev 获取交易签名数量
     */
    function getTransactionSignaturesCount(bytes32 _transactionId) external view returns (uint256) {
        return transactions[_transactionId].signaturesCount;
    }
    
    /**
     * @dev 检查验证者是否已签名
     */
    function hasValidatorSigned(bytes32 _transactionId, address _validator) external view returns (bool) {
        return transactions[_transactionId].signatures[_validator];
    }
    
    /**
     * @dev 获取交易详情
     */
    function getTransactionDetails(bytes32 _transactionId) external view returns (
        address user,
        uint256 amount,
        string memory sourceChain,
        string memory targetChain,
        uint256 timestamp,
        TransactionStatus status,
        uint256 signaturesCount
    ) {
        Transaction storage transaction = transactions[_transactionId];
        return (
            transaction.user,
            transaction.amount,
            transaction.sourceChain,
            transaction.targetChain,
            transaction.timestamp,
            transaction.status,
            transaction.signaturesCount
        );
    }
}

// 跨链桥风险评估工具
class BridgeRiskAssessor {
  constructor() {
    // 风险因素权重
    this.riskWeights = {
      tvl: 0.2,        // 总锁仓价值
      auditScore: 0.25, // 审计评分
      securityHistory: 0.2, // 安全历史
      validatorCount: 0.15, // 验证者数量
      codeOpenSource: 0.05, // 代码开源状态
      insuranceCoverage: 0.15 // 保险覆盖
    };
    
    // 风险等级阈值
    this.riskLevels = {
      low: 0.3,
      medium: 0.6,
      high: 1.0
    };
  }
  
  // 评估跨链桥风险
  assessBridgeRisk(bridgeData) {
    console.log(`开始评估跨链桥风险: ${bridgeData.name}`);
    
    // 验证输入数据
    if (!this.validateBridgeData(bridgeData)) {
      throw new Error('无效的跨链桥数据');
    }
    
    // 计算各项风险分数
    const tvlScore = this.calculateTvlScore(bridgeData.tvl);
    const auditScore = bridgeData.auditScore / 100;
    const securityHistoryScore = this.calculateSecurityHistoryScore(bridgeData.securityIncidents);
    const validatorScore = this.calculateValidatorScore(bridgeData.validatorCount, bridgeData.threshold);
    const openSourceScore = bridgeData.isOpenSource ? 1 : 0;
    const insuranceScore = this.calculateInsuranceScore(bridgeData.insuranceCoverage);
    
    // 计算加权风险分数（越低越安全）
    const riskScore = 1 - (
      tvlScore * this.riskWeights.tvl +
      auditScore * this.riskWeights.auditScore +
      securityHistoryScore * this.riskWeights.securityHistory +
      validatorScore * this.riskWeights.validatorCount +
      openSourceScore * this.riskWeights.codeOpenSource +
      insuranceScore * this.riskWeights.insuranceCoverage
    );
    
    // 确定风险等级
    const riskLevel = this.determineRiskLevel(riskScore);
    
    // 生成建议
    const recommendations = this.generateRecommendations(riskLevel, bridgeData);
    
    // 生成风险报告
    const riskReport = {
      bridgeName: bridgeData.name,
      riskScore: riskScore.toFixed(2),
      riskLevel,
      detailedScores: {
        tvlScore: (tvlScore * 100).toFixed(1),
        auditScore: (auditScore * 100).toFixed(1),
        securityHistoryScore: (securityHistoryScore * 100).toFixed(1),
        validatorScore: (validatorScore * 100).toFixed(1),
        openSourceScore: (openSourceScore * 100).toFixed(1),
        insuranceScore: (insuranceScore * 100).toFixed(1)
      },
      recommendations
    };
    
    console.log(`风险评估完成: ${bridgeData.name} - 风险等级: ${riskLevel} (分数: ${riskScore.toFixed(2)})`);
    return riskReport;
  }
  
  // 验证桥接数据
  validateBridgeData(bridgeData) {
    if (!bridgeData || !bridgeData.name) {
      return false;
    }
    
    const requiredFields = ['tvl', 'auditScore', 'securityIncidents', 'validatorCount', 'threshold'];
    return requiredFields.every(field => bridgeData.hasOwnProperty(field));
  }
  
  // 计算TVL分数（TVL越高越安全）
  calculateTvlScore(tvl) {
    if (tvl >= 1000000000) { // 10亿美元以上
      return 1.0;
    } else if (tvl >= 500000000) { // 5-10亿美元
      return 0.8;
    } else if (tvl >= 100000000) { // 1-5亿美元
      return 0.6;
    } else if (tvl >= 10000000) { // 1000-5000万美元
      return 0.4;
    } else {
      return 0.2;
    }
  }
  
  // 计算安全历史分数
  calculateSecurityHistoryScore(incidents) {
    if (!incidents || incidents.length === 0) {
      return 1.0;
    } else if (incidents.length === 1) {
      // 检查最近是否有事件
      const oneYearAgo = Date.now() - (365 * 24 * 60 * 60 * 1000);
      const recentIncident = incidents.some(incident => incident.timestamp > oneYearAgo);
      return recentIncident ? 0.4 : 0.7;
    } else {
      return 0.2;
    }
  }
  
  // 计算验证者分数
  calculateValidatorScore(validatorCount, threshold) {
    if (validatorCount < 3) {
      return 0.2; // 验证者太少
    }
    
    // 计算阈值比例
    const thresholdRatio = threshold / validatorCount;
    
    if (thresholdRatio >= 0.75) { // 至少需要3/4的验证者同意
      return 1.0;
    } else if (thresholdRatio >= 0.67) { // 至少需要2/3的验证者同意
      return 0.8;
    } else if (thresholdRatio >= 0.5) { // 至少需要1/2的验证者同意
      return 0.6;
    } else {
      return 0.3; // 阈值过低
    }
  }
  
  // 计算保险覆盖分数
  calculateInsuranceScore(insuranceCoverage) {
    if (!insuranceCoverage || insuranceCoverage === 0) {
      return 0.2;
    } else if (insuranceCoverage >= 0.8) { // 80%以上覆盖
      return 1.0;
    } else if (insuranceCoverage >= 0.5) { // 50-80%覆盖
      return 0.7;
    } else if (insuranceCoverage >= 0.2) { // 20-50%覆盖
      return 0.4;
    } else {
      return 0.2;
    }
  }
  
  // 确定风险等级
  determineRiskLevel(score) {
    if (score <= this.riskLevels.low) {
      return '低风险';
    } else if (score <= this.riskLevels.medium) {
      return '中风险';
    } else {
      return '高风险';
    }
  }
  
  // 生成使用建议
  generateRecommendations(riskLevel, bridgeData) {
    const recommendations = [];
    
    // 基于风险等级的通用建议
    if (riskLevel === '高风险') {
      recommendations.push('不建议使用此跨链桥进行大额转账');
      recommendations.push('如果必须使用，建议将金额限制在总资产的5%以内');
      recommendations.push('考虑使用多重验证的转账方式');
    } else if (riskLevel === '中风险') {
      recommendations.push('建议限制单次转账金额不超过总资产的10%');
      recommendations.push('定期检查跨链桥的最新安全状态');
      recommendations.push('考虑分散使用多个跨链桥');
    } else {
      recommendations.push('可以相对安全地使用此跨链桥');
      recommendations.push('但仍建议分散风险，不将所有资产通过单一桥转移');
    }
    
    // 基于具体问题的建议
    if (bridgeData.validatorCount < 7) {
      recommendations.push('验证者数量较少，存在中心化风险，建议谨慎使用');
    }
    
    if (bridgeData.securityIncidents && bridgeData.securityIncidents.length > 0) {
      recommendations.push('此跨链桥历史上曾发生安全事件，建议先了解事件原因和修复情况');
    }
    
    if (!bridgeData.isOpenSource) {
      recommendations.push('代码未完全开源，透明度较低，建议减少使用频率');
    }
    
    if (!bridgeData.hasInsurance) {
      recommendations.push('没有保险覆盖，建议购买第三方跨链保险或减少转账金额');
    }
    
    // 添加通用安全建议
    recommendations.push('转账前仔细验证目标地址');
    recommendations.push('首次使用时先进行小额测试转账');
    recommendations.push('关注跨链桥官方渠道的安全公告');
    
    return recommendations;
  }
}

// 使用示例
function analyzeBridgeExample() {
  const assessor = new BridgeRiskAssessor();
  
  // 示例跨链桥数据
  const bridgeExamples = [
    {
      name: 'Polygon PoS Bridge',
      tvl: 2230000000, // 22.3亿美元
      auditScore: 92,
      securityIncidents: [],
      validatorCount: 100,
      threshold: 75,
      isOpenSource: true,
      hasInsurance: true,
      insuranceCoverage: 0.65
    },
    {
      name: 'Wormhole',
      tvl: 2850000000, // 28.5亿美元
      auditScore: 88,
      securityIncidents: [
        { timestamp: Date.now() - (450 * 24 * 60 * 60 * 1000), amount: 320000000 }
      ],
      validatorCount: 19,
      threshold: 13,
      isOpenSource: true,
      hasInsurance: true,
      insuranceCoverage: 0.8
    },
    {
      name: 'NewBridge',
      tvl: 50000000, // 5000万美元
      auditScore: 75,
      securityIncidents: [],
      validatorCount: 5,
      threshold: 3,
      isOpenSource: false,
      hasInsurance: false,
      insuranceCoverage: 0
    }
  ];
  
  // 分析每个跨链桥
  bridgeExamples.forEach(bridge => {
    try {
      console.log('\n====================================');
      console.log(`分析跨链桥: ${bridge.name}`);
      const result = assessor.assessBridgeRisk(bridge);
      console.log('风险评分:', result.riskScore);
      console.log('风险等级:', result.riskLevel);
      console.log('详细评分:');
      Object.entries(result.detailedScores).forEach(([key, value]) => {
        console.log(`  ${key}: ${value}%`);
      });
      console.log('使用建议:');
      result.recommendations.forEach(rec => {
        console.log(`  - ${rec}`);
      });
    } catch (error) {
      console.error(`分析${bridge.name}失败:`, error);
    }
  });
}

// 运行分析
analyzeBridgeExample();

跨链桥紧急情况应对流程：
1. 交易未确认：保持页面打开，等待确认完成
2. 交易异常：联系跨链桥官方支持，提供交易哈希
3. 资金未到账：检查交易哈希在目标链上的状态，联系客服
4. 发现漏洞：通过官方漏洞赏金计划报告，不要公开披露
5. 遭受攻击：立即停止使用，关注官方应急响应，必要时寻求法律帮助

// 跨链桥实时监控系统
class BridgeMonitoringSystem {
  constructor(alertThresholds = {}) {
    // 告警阈值配置
    this.thresholds = {
      transactionVolumeIncrease: 50, // 交易量增长百分比阈值
      largeTransactionAmount: 1000000, // 大额交易金额阈值（美元）
      validatorResponseTime: 300, // 验证者响应时间阈值（秒）
      failedTransactionRate: 5, // 失败交易率阈值（百分比）
      unusualAddressActivity: 3, // 异常地址活动阈值（短时间内交易次数）
      ...alertThresholds
    };
    
    // 监控数据存储
    this.monitoringData = {
      transactions: [],
      validators: {},
      dailyStats: {},
      anomalies: [],
      alerts: []
    };
    
    // 历史数据缓存（用于比较）
    this.historicalData = {
      hourlyVolumes: [],
      dailyVolumes: [],
      validatorPerformance: []
    };
    
    // 监控状态
    this.isMonitoringActive = false;
    
    // 监控间隔（毫秒）
    this.monitoringInterval = 60000; // 1分钟
  }
  
  // 启动监控系统
  startMonitoring() {
    if (this.isMonitoringActive) {
      console.log('监控系统已经在运行中');
      return;
    }
    
    console.log('启动跨链桥监控系统...');
    this.isMonitoringActive = true;
    
    // 初始化历史数据
    this.initializeHistoricalData();
    
    // 设置定时监控
    this.monitoringTimer = setInterval(() => {
      this.performMonitoringCheck();
    }, this.monitoringInterval);
    
    console.log('监控系统启动成功，监控间隔:', this.monitoringInterval / 1000, '秒');
  }
  
  // 停止监控系统
  stopMonitoring() {
    if (!this.isMonitoringActive) {
      console.log('监控系统未运行');
      return;
    }
    
    console.log('停止跨链桥监控系统...');
    clearInterval(this.monitoringTimer);
    this.isMonitoringActive = false;
    console.log('监控系统已停止');
  }
  
  // 初始化历史数据
  initializeHistoricalData() {
    console.log('初始化历史监控数据...');
    
    // 模拟过去24小时的小时交易量数据
    const now = Date.now();
    for (let i = 24; i >= 0; i--) {
      const timestamp = now - (i * 60 * 60 * 1000);
      const volume = this.generateRandomVolume(500000, 2000000); // 50-200万美元
      
      this.historicalData.hourlyVolumes.push({
        timestamp,
        volume
      });
    }
    
    // 模拟过去7天的日交易量数据
    for (let i = 7; i >= 0; i--) {
      const timestamp = now - (i * 24 * 60 * 60 * 1000);
      const volume = this.generateRandomVolume(5000000, 30000000); // 500万-3000万美元
      
      this.historicalData.dailyVolumes.push({
        timestamp,
        volume
      });
    }
    
    console.log('历史数据初始化完成');
  }
  
  // 执行监控检查
  performMonitoringCheck() {
    const now = Date.now();
    console.log(`执行监控检查 - ${new Date(now).toISOString()}`);
    
    // 模拟收集最新交易数据
    this.collectTransactionData();
    
    // 检查交易量异常
    this.checkTransactionVolumeAnomalies();
    
    // 检查大额交易
    this.checkLargeTransactions();
    
    // 检查验证者性能
    this.checkValidatorPerformance();
    
    // 检查失败交易率
    this.checkFailedTransactionRate();
    
    // 检查异常地址活动
    this.checkUnusualAddressActivity();
    
    // 更新历史数据
    this.updateHistoricalData();
    
    // 生成监控报告
    this.generateMonitoringReport();
  }
  
  // 收集交易数据
  collectTransactionData() {
    // 在实际系统中，这里会从区块链或API获取真实交易数据
    // 这里我们模拟生成一些交易数据
    const now = Date.now();
    const transactionCount = this.generateRandomNumber(10, 50);
    
    console.log(`收集到 ${transactionCount} 笔新交易`);
    
    for (let i = 0; i < transactionCount; i++) {
      const amount = this.generateRandomVolume(100, 5000000); // 100美元到500万美元
      const isLarge = amount > this.thresholds.largeTransactionAmount;
      const success = Math.random() > 0.02; // 98%成功率
      
      const transaction = {
        id: `tx_${now}_${i}`,
        timestamp: now - (i * 10000), // 模拟交易时间分布
        fromAddress: this.generateRandomAddress(),
        toAddress: this.generateRandomAddress(),
        amount,
        isLarge,
        success,
        sourceChain: this.getRandomChain(),
        targetChain: this.getRandomChain(),
        validationTime: success ? this.generateRandomNumber(30, 600) : null // 30秒到10分钟
      };
      
      this.monitoringData.transactions.push(transaction);
    }
    
    // 限制交易记录数量，避免内存占用过大
    if (this.monitoringData.transactions.length > 1000) {
      this.monitoringData.transactions = this.monitoringData.transactions.slice(-1000);
    }
  }
  
  // 检查交易量异常
  checkTransactionVolumeAnomalies() {
    const now = Date.now();
    const oneHourAgo = now - (60 * 60 * 1000);
    
    // 计算当前小时交易量
    const currentHourTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo
    );
    
    const currentHourVolume = currentHourTransactions.reduce((sum, tx) => sum + tx.amount, 0);
    
    // 获取前一个小时的交易量
    const previousHourTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo - (60 * 60 * 1000) && tx.timestamp < oneHourAgo
    );
    
    const previousHourVolume = previousHourTransactions.reduce((sum, tx) => sum + tx.amount, 0);
    
    // 计算交易量增长率
    let growthRate = 0;
    if (previousHourVolume > 0) {
      growthRate = ((currentHourVolume - previousHourVolume) / previousHourVolume) * 100;
    }
    
    console.log(`交易量分析 - 当前小时: $${currentHourVolume.toLocaleString()}, 增长率: ${growthRate.toFixed(2)}%`);
    
    // 检查是否超过阈值
    if (growthRate > this.thresholds.transactionVolumeIncrease) {
      const anomaly = {
        type: 'TRANSACTION_VOLUME_SPIKE',
        timestamp: now,
        currentVolume: currentHourVolume,
        previousVolume: previousHourVolume,
        growthRate,
        threshold: this.thresholds.transactionVolumeIncrease,
        severity: growthRate > this.thresholds.transactionVolumeIncrease * 2 ? '高' : '中'
      };
      
      this.monitoringData.anomalies.push(anomaly);
      this.createAlert(anomaly);
    }
  }
  
  // 检查大额交易
  checkLargeTransactions() {
    const now = Date.now();
    const oneHourAgo = now - (60 * 60 * 1000);
    
    // 查找大额交易
    const largeTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo && tx.amount > this.thresholds.largeTransactionAmount
    );
    
    if (largeTransactions.length > 0) {
      console.log(`检测到 ${largeTransactions.length} 笔大额交易`);
      
      largeTransactions.forEach(tx => {
        const anomaly = {
          type: 'LARGE_TRANSACTION',
          timestamp: now,
          transactionId: tx.id,
          amount: tx.amount,
          fromAddress: tx.fromAddress,
          toAddress: tx.toAddress,
          sourceChain: tx.sourceChain,
          targetChain: tx.targetChain,
          threshold: this.thresholds.largeTransactionAmount,
          severity: tx.amount > this.thresholds.largeTransactionAmount * 3 ? '高' : '中'
        };
        
        this.monitoringData.anomalies.push(anomaly);
        this.createAlert(anomaly);
      });
    }
  }
  
  // 检查验证者性能
  checkValidatorPerformance() {
    const now = Date.now();
    const oneHourAgo = now - (60 * 60 * 1000);
    
    // 分析交易验证时间
    const recentTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo && tx.validationTime !== null
    );
    
    if (recentTransactions.length > 0) {
      // 计算平均验证时间
      const avgValidationTime = recentTransactions.reduce(
        (sum, tx) => sum + tx.validationTime, 0
      ) / recentTransactions.length;
      
      console.log(`验证者性能分析 - 平均验证时间: ${avgValidationTime.toFixed(2)}秒`);
      
      // 检查是否超过阈值
      if (avgValidationTime > this.thresholds.validatorResponseTime) {
        const anomaly = {
          type: 'VALIDATOR_RESPONSE_DELAY',
          timestamp: now,
          avgValidationTime,
          transactionCount: recentTransactions.length,
          threshold: this.thresholds.validatorResponseTime,
          severity: avgValidationTime > this.thresholds.validatorResponseTime * 2 ? '高' : '中'
        };
        
        this.monitoringData.anomalies.push(anomaly);
        this.createAlert(anomaly);
      }
    }
  }
  
  // 检查失败交易率
  checkFailedTransactionRate() {
    const now = Date.now();
    const oneHourAgo = now - (60 * 60 * 1000);
    
    // 获取最近的交易
    const recentTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo
    );
    
    if (recentTransactions.length > 0) {
      // 计算失败交易数量
      const failedTransactions = recentTransactions.filter(tx => !tx.success);
      const failureRate = (failedTransactions.length / recentTransactions.length) * 100;
      
      console.log(`失败交易率分析 - 当前失败率: ${failureRate.toFixed(2)}%`);
      
      // 检查是否超过阈值
      if (failureRate > this.thresholds.failedTransactionRate) {
        const anomaly = {
          type: 'HIGH_FAILURE_RATE',
          timestamp: now,
          failureRate,
          totalTransactions: recentTransactions.length,
          failedTransactions: failedTransactions.length,
          threshold: this.thresholds.failedTransactionRate,
          severity: failureRate > this.thresholds.failedTransactionRate * 2 ? '高' : '中'
        };
        
        this.monitoringData.anomalies.push(anomaly);
        this.createAlert(anomaly);
      }
    }
  }
  
  // 检查异常地址活动
  checkUnusualAddressActivity() {
    const now = Date.now();
    const oneHourAgo = now - (60 * 60 * 1000);
    
    // 获取最近的交易
    const recentTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo
    );
    
    // 统计地址活动
    const addressActivity = {};
    
    recentTransactions.forEach(tx => {
      // 统计发送方活动
      if (!addressActivity[tx.fromAddress]) {
        addressActivity[tx.fromAddress] = 0;
      }
      addressActivity[tx.fromAddress]++;
      
      // 统计接收方活动
      if (!addressActivity[tx.toAddress]) {
        addressActivity[tx.toAddress] = 0;
      }
      addressActivity[tx.toAddress]++;
    });
    
    // 查找异常活跃的地址
    const unusualAddresses = Object.entries(addressActivity)
      .filter(([address, count]) => count >= this.thresholds.unusualAddressActivity)
      .map(([address, count]) => ({ address, count }));
    
    if (unusualAddresses.length > 0) {
      console.log(`检测到 ${unusualAddresses.length} 个异常活跃的地址`);
      
      unusualAddresses.forEach(addr => {
        const anomaly = {
          type: 'UNUSUAL_ADDRESS_ACTIVITY',
          timestamp: now,
          address: addr.address,
          transactionCount: addr.count,
          threshold: this.thresholds.unusualAddressActivity,
          severity: addr.count > this.thresholds.unusualAddressActivity * 3 ? '高' : '中'
        };
        
        this.monitoringData.anomalies.push(anomaly);
        this.createAlert(anomaly);
      });
    }
  }
  
  // 创建告警
  createAlert(anomaly) {
    const alertId = `alert_${anomaly.timestamp}_${this.monitoringData.alerts.length}`;
    
    const alert = {
      id: alertId,
      ...anomaly,
      status: 'NEW',
      createdAt: anomaly.timestamp,
      acknowledged: false,
      acknowledgedBy: null,
      acknowledgedAt: null,
      resolved: false,
      resolvedBy: null,
      resolvedAt: null
    };
    
    this.monitoringData.alerts.push(alert);
    console.log(`创建新告警: ${alertId} - ${anomaly.type} (严重程度: ${anomaly.severity})`);
    
    // 在实际系统中，这里会触发通知（邮件、短信、Slack等）
    this.sendAlertNotification(alert);
  }
  
  // 发送告警通知
  sendAlertNotification(alert) {
    console.log(`\n===== 告警通知 =====`);
    console.log(`告警ID: ${alert.id}`);
    console.log(`类型: ${alert.type}`);
    console.log(`时间: ${new Date(alert.createdAt).toISOString()}`);
    console.log(`严重程度: ${alert.severity}`);
    console.log(`详情:`);
    
    // 显示告警详情
    switch (alert.type) {
      case 'TRANSACTION_VOLUME_SPIKE':
        console.log(`  - 当前交易量: $${alert.currentVolume.toLocaleString()}`);
        console.log(`  - 前一小时交易量: $${alert.previousVolume.toLocaleString()}`);
        console.log(`  - 增长率: ${alert.growthRate.toFixed(2)}%`);
        break;
      case 'LARGE_TRANSACTION':
        console.log(`  - 交易ID: ${alert.transactionId}`);
        console.log(`  - 金额: $${alert.amount.toLocaleString()}`);
        console.log(`  - 发送方: ${alert.fromAddress}`);
        console.log(`  - 接收方: ${alert.toAddress}`);
        console.log(`  - 源链: ${alert.sourceChain}`);
        console.log(`  - 目标链: ${alert.targetChain}`);
        break;
      case 'VALIDATOR_RESPONSE_DELAY':
        console.log(`  - 平均验证时间: ${alert.avgValidationTime.toFixed(2)}秒`);
        console.log(`  - 交易数量: ${alert.transactionCount}`);
        break;
      case 'HIGH_FAILURE_RATE':
        console.log(`  - 失败率: ${alert.failureRate.toFixed(2)}%`);
        console.log(`  - 总交易数: ${alert.totalTransactions}`);
        console.log(`  - 失败交易数: ${alert.failedTransactions}`);
        break;
      case 'UNUSUAL_ADDRESS_ACTIVITY':
        console.log(`  - 地址: ${alert.address}`);
        console.log(`  - 交易次数: ${alert.transactionCount}`);
        break;
    }
    
    console.log(`==================\n`);
  }
  
  // 更新历史数据
  updateHistoricalData() {
    const now = Date.now();
    
    // 计算当前小时交易量
    const oneHourAgo = now - (60 * 60 * 1000);
    const currentHourVolume = this.monitoringData.transactions
      .filter(tx => tx.timestamp >= oneHourAgo)
      .reduce((sum, tx) => sum + tx.amount, 0);
    
    // 添加到历史小时交易量
    this.historicalData.hourlyVolumes.push({
      timestamp: now,
      volume: currentHourVolume
    });
    
    // 限制历史小时数据数量
    if (this.historicalData.hourlyVolumes.length > 168) { // 保留7天的数据
      this.historicalData.hourlyVolumes = this.historicalData.hourlyVolumes.slice(-168);
    }
    
    // 检查是否需要更新日交易量（这里简化处理，实际应该在每天固定时间更新）
    const todayStart = new Date(now);
    todayStart.setHours(0, 0, 0, 0);
    
    const todayVolume = this.monitoringData.transactions
      .filter(tx => tx.timestamp >= todayStart.getTime())
      .reduce((sum, tx) => sum + tx.amount, 0);
    
    // 更新或添加今日交易量
    const todayIndex = this.historicalData.dailyVolumes.findIndex(
      day => new Date(day.timestamp).toDateString() === todayStart.toDateString()
    );
    
    if (todayIndex >= 0) {
      this.historicalData.dailyVolumes[todayIndex].volume = todayVolume;
    } else {
      this.historicalData.dailyVolumes.push({
        timestamp: todayStart.getTime(),
        volume: todayVolume
      });
    }
    
    // 限制历史日数据数量
    if (this.historicalData.dailyVolumes.length > 30) { // 保留30天的数据
      this.historicalData.dailyVolumes = this.historicalData.dailyVolumes.slice(-30);
    }
  }
  
  // 生成监控报告
  generateMonitoringReport() {
    const now = Date.now();
    const oneHourAgo = now - (60 * 60 * 1000);
    const oneDayAgo = now - (24 * 60 * 60 * 1000);
    
    // 统计最近1小时的交易
    const hourlyTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneHourAgo
    );
    
    // 统计最近24小时的交易
    const dailyTransactions = this.monitoringData.transactions.filter(
      tx => tx.timestamp >= oneDayAgo
    );
    
    // 计算统计数据
    const report = {
      timestamp: now,
      period: 'hourly',
      transactionStats: {
        totalCount: hourlyTransactions.length,
        successCount: hourlyTransactions.filter(tx => tx.success).length,
        failedCount: hourlyTransactions.filter(tx => !tx.success).length,
        successRate: hourlyTransactions.length > 0 ? 
          (hourlyTransactions.filter(tx => tx.success).length / hourlyTransactions.length) * 100 : 0,
        totalVolume: hourlyTransactions.reduce((sum, tx) => sum + tx.amount, 0),
        avgTransactionAmount: hourlyTransactions.length > 0 ? 
          hourlyTransactions.reduce((sum, tx) => sum + tx.amount, 0) / hourlyTransactions.length : 0,
        largeTransactionCount: hourlyTransactions.filter(tx => tx.isLarge).length
      },
      dailyStats: {
        totalCount: dailyTransactions.length,
        totalVolume: dailyTransactions.reduce((sum, tx) => sum + tx.amount, 0),
        largeTransactionCount: dailyTransactions.filter(tx => tx.isLarge).length
      },
      anomalyStats: {
        totalAnomalies: this.monitoringData.anomalies.filter(
          a => a.timestamp >= oneHourAgo
        ).length,
        highSeverityCount: this.monitoringData.anomalies.filter(
          a => a.timestamp >= oneHourAgo && a.severity === '高'
        ).length,
        mediumSeverityCount: this.monitoringData.anomalies.filter(
          a => a.timestamp >= oneHourAgo && a.severity === '中'
        ).length
      },
      alertStats: {
        totalAlerts: this.monitoringData.alerts.filter(
          a => a.createdAt >= oneHourAgo
        ).length,
        newAlerts: this.monitoringData.alerts.filter(
          a => a.createdAt >= oneHourAgo && a.status === 'NEW'
        ).length,
        resolvedAlerts: this.monitoringData.alerts.filter(
          a => a.resolvedAt >= oneHourAgo
        ).length
      }
    };
    
    // 保存报告（实际系统中可能会存储到数据库）
    this.monitoringData.dailyStats[now] = report;
    
    // 输出报告摘要
    console.log(`\n===== 监控报告摘要 =====`);
    console.log(`时间: ${new Date(now).toISOString()}`);
    console.log(`最近1小时交易: ${report.transactionStats.totalCount} 笔 ($${report.transactionStats.totalVolume.toLocaleString()})`);
    console.log(`成功率: ${report.transactionStats.successRate.toFixed(2)}%`);
    console.log(`大额交易: ${report.transactionStats.largeTransactionCount} 笔`);
    console.log(`异常检测: ${report.anomalyStats.totalAnomalies} 个 (高: ${report.anomalyStats.highSeverityCount}, 中: ${report.anomalyStats.mediumSeverityCount})`);
    console.log(`告警数量: ${report.alertStats.totalAlerts} 个 (新: ${report.alertStats.newAlerts}, 已解决: ${report.alertStats.resolvedAlerts})`);
    console.log(`======================\n`);
    
    return report;
  }
  
  // 确认告警
  acknowledgeAlert(alertId, user) {
    const alertIndex = this.monitoringData.alerts.findIndex(a => a.id === alertId);
    
    if (alertIndex === -1) {
      console.log(`告警 ${alertId} 不存在`);
      return false;
    }
    
    const alert = this.monitoringData.alerts[alertIndex];
    
    if (alert.acknowledged) {
      console.log(`告警 ${alertId} 已经被确认`);
      return false;
    }
    
    alert.acknowledged = true;
    alert.acknowledgedBy = user;
    alert.acknowledgedAt = Date.now();
    alert.status = 'ACKNOWLEDGED';
    
    console.log(`告警 ${alertId} 已被 ${user} 确认`);
    return true;
  }
  
  // 解决告警
  resolveAlert(alertId, user, resolutionNotes = '') {
    const alertIndex = this.monitoringData.alerts.findIndex(a => a.id === alertId);
    
    if (alertIndex === -1) {
      console.log(`告警 ${alertId} 不存在`);
      return false;
    }
    
    const alert = this.monitoringData.alerts[alertIndex];
    
    if (alert.resolved) {
      console.log(`告警 ${alertId} 已经被解决`);
      return false;
    }
    
    alert.resolved = true;
    alert.resolvedBy = user;
    alert.resolvedAt = Date.now();
    alert.resolutionNotes = resolutionNotes;
    alert.status = 'RESOLVED';
    
    console.log(`告警 ${alertId} 已被 ${user} 解决`);
    if (resolutionNotes) {
      console.log(`解决说明: ${resolutionNotes}`);
    }
    return true;
  }
  
  // 获取未解决的告警
  getUnresolvedAlerts() {
    return this.monitoringData.alerts.filter(alert => !alert.resolved);
  }
  
  // 获取指定时间范围内的告警
  getAlertsByTimeRange(startTime, endTime) {
    return this.monitoringData.alerts.filter(
      alert => alert.createdAt >= startTime && alert.createdAt <= endTime
    );
  }
  
  // 设置告警阈值
  setAlertThresholds(newThresholds) {
    this.thresholds = { ...this.thresholds, ...newThresholds };
    console.log('告警阈值已更新:', this.thresholds);
  }
  
  // 辅助函数：生成随机数量
  generateRandomNumber(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
  }
  
  // 辅助函数：生成随机交易量
  generateRandomVolume(min, max) {
    return Math.random() * (max - min) + min;
  }
  
  // 辅助函数：生成随机地址
  generateRandomAddress() {
    const chars = '0123456789abcdef';
    let address = '0x';
    for (let i = 0; i < 40; i++) {
      address += chars.charAt(Math.floor(Math.random() * chars.length));
    }
    return address;
  }
  
  // 辅助函数：获取随机链
  getRandomChain() {
    const chains = ['ethereum', 'polygon', 'avalanche', 'binance', 'solana', 'arbitrum', 'optimism'];
    return chains[Math.floor(Math.random() * chains.length)];
  }
}

// 使用示例
function monitoringSystemDemo() {
  console.log('跨链桥监控系统演示启动...');
  
  // 创建监控系统实例
  const monitoringSystem = new BridgeMonitoringSystem({
    transactionVolumeIncrease: 40, // 交易量增长阈值设为40%
    largeTransactionAmount: 500000, // 大额交易阈值设为50万美元
    validatorResponseTime: 240, // 验证响应时间阈值设为240秒
    failedTransactionRate: 3, // 失败交易率阈值设为3%
    unusualAddressActivity: 5 // 异常地址活动阈值设为5次
  });
  
  // 启动监控系统
  monitoringSystem.startMonitoring();
  
  // 模拟运行一段时间后停止
  setTimeout(() => {
    console.log('\n演示结束，停止监控系统...');
    monitoringSystem.stopMonitoring();
    
    // 显示未解决的告警
    const unresolvedAlerts = monitoringSystem.getUnresolvedAlerts();
    console.log(`\n未解决的告警数量: ${unresolvedAlerts.length}`);
    
    if (unresolvedAlerts.length > 0) {
      console.log('最近的5个未解决告警:');
      unresolvedAlerts.slice(0, 5).forEach(alert => {
        console.log(`- ${alert.id}: ${alert.type} (${alert.severity}严重)`);
      });
    }
    
  }, 300000); // 运行5分钟后停止
}

// 运行监控系统演示
// monitoringSystemDemo();