智能合约交互安全

在Web3前端开发中，智能合约交互是最核心也最具风险的环节。前端应用作为用户与区块链交互的桥梁，必须严格遵循安全最佳实践，防止用户资产被盗、交易被篡改或遭受其他形式的攻击。本文将详细介绍智能合约交互的安全原则、常见风险及防护措施。

一、智能合约交互的安全原则

1.1 最小权限原则

智能合约交互应遵循最小权限原则，仅请求完成当前任务所需的最低权限。

// 智能合约交互权限管理器
const PermissionManager = {
  // 定义不同操作所需的最小权限级别
  permissionLevels: {
    'VIEW_BALANCE': { requiresApproval: false, description: '查看余额' },
    'TRANSFER_TOKEN': { requiresApproval: true, description: '转账操作', maxAmount: null },
    'APPROVE_TOKEN': { requiresApproval: true, description: '授权操作', maxAmount: null },
    'CONTRACT_INTERACTION': { requiresApproval: true, description: '合约交互', maxAmount: null }
  },
  
  // 检查权限是否足够
  checkPermission(operation, userPermissionLevel) {
    const requiredPermission = this.permissionLevels[operation];
    if (!requiredPermission) {
      console.warn(`未知的操作类型: ${operation}`);
      return false;
    }
    
    // 这里可以实现更复杂的权限检查逻辑
    return userPermissionLevel >= this.getPermissionLevel(operation);
  },
  
  // 获取操作所需的权限级别
  getPermissionLevel(operation) {
    const permission = this.permissionLevels[operation];
    if (!permission) return 0;
    
    return permission.requiresApproval ? 2 : 1;
  },
  
  // 验证交易参数是否符合最小权限原则
  validateTransactionParams(operation, params) {
    const permission = this.permissionLevels[operation];
    if (!permission) return { valid: false, reason: '未知操作类型' };
    
    // 检查转账/授权金额是否合理
    if (params.amount && permission.maxAmount !== null) {
      if (params.amount > permission.maxAmount) {
        return { 
          valid: false, 
          reason: `金额超过最大限制: ${permission.maxAmount}` 
        };
      }
    }
    
    // 检查gas设置是否合理
    if (params.gasPrice && params.gasPrice > this.getCurrentNetworkGasPrice() * 3) {
      return { 
        valid: false, 
        reason: 'gas价格过高，可能存在风险' 
      };
    }
    
    return { valid: true };
  },
  
  // 获取当前网络的平均gas价格
  getCurrentNetworkGasPrice() {
    // 实际应用中应从区块链网络获取
    // 这里返回示例值
    return 20; // gwei
  }
};

// 使用示例：验证转账交易权限
function validateTransferTransaction(tokenAddress, toAddress, amount) {
  // 检查操作权限
  const hasPermission = PermissionManager.checkPermission('TRANSFER_TOKEN', 2);
  if (!hasPermission) {
    throw new Error('当前用户权限不足，无法执行转账操作');
  }
  
  // 验证交易参数
  const validationResult = PermissionManager.validateTransactionParams('TRANSFER_TOKEN', { amount });
  if (!validationResult.valid) {
    throw new Error(`交易参数验证失败: ${validationResult.reason}`);
  }
  
  // 额外的安全检查
  if (!this.isValidAddress(toAddress)) {
    throw new Error('目标地址无效');
  }
  
  // 记录授权日志
  this.logPermissionRequest('TRANSFER_TOKEN', { tokenAddress, toAddress, amount });
  
  return true;
}

1.2 交易透明原则

确保用户在确认交易前能够清楚了解交易的所有细节和潜在风险。

// 交易详情展示器
const TransactionDisplayer = {
  // 格式化交易详情以便用户查看
  formatTransactionDetails(transaction) {
    const { type, contractAddress, functionName, params, value, gasLimit, gasPrice, tokenSymbol } = transaction;
    
    let details = {
      type: this.getTransactionTypeName(type),
      contract: contractAddress,
      function: functionName,
      value: value ? `${this.formatWei(value)} ETH` : '0 ETH',
      gas: `${gasLimit} units @ ${this.formatGwei(gasPrice)} gwei`,
      estimatedCost: this.estimateTransactionCost(gasLimit, gasPrice),
      riskLevel: this.assessTransactionRisk(transaction),
      params: this.formatParams(params)
    };
    
    // 如果是代币操作，添加代币信息
    if (tokenSymbol) {
      details.token = tokenSymbol;
    }
    
    return details;
  },
  
  // 获取交易类型的可读名称
  getTransactionTypeName(type) {
    const typeNames = {
      'transfer': '以太币转账',
      'token_transfer': '代币转账',
      'approve': '代币授权',
      'contract_call': '合约调用',
      'mint': '铸造NFT',
      'swap': '资产交换'
    };
    
    return typeNames[type] || '未知交易类型';
  },
  
  // 格式化wei为可读的ETH
  formatWei(wei) {
    // 使用ethers.js或web3.js的格式化功能
    try {
      const ethers = window.ethers || require('ethers');
      return ethers.utils.formatEther(wei);
    } catch (error) {
      // 备用简单格式化
      return (parseInt(wei) / 1e18).toFixed(6);
    }
  },
  
  // 格式化gwei
  formatGwei(gwei) {
    return gwei.toString();
  },
  
  // 估算交易成本
  estimateTransactionCost(gasLimit, gasPrice) {
    try {
      const ethers = window.ethers || require('ethers');
      const totalWei = ethers.BigNumber.from(gasLimit).mul(gasPrice);
      return `${this.formatWei(totalWei)} ETH`;
    } catch (error) {
      // 备用计算
      const totalWei = parseInt(gasLimit) * parseInt(gasPrice) * 1e9;
      return `${(totalWei / 1e18).toFixed(6)} ETH`;
    }
  },
  
  // 评估交易风险等级
  assessTransactionRisk(transaction) {
    const { type, value, params } = transaction;
    let riskScore = 0;
    
    // 根据交易类型评估风险
    const typeRiskMap = {
      'transfer': 1,
      'token_transfer': 1,
      'approve': 3,
      'contract_call': 2,
      'mint': 1,
      'swap': 2
    };
    
    riskScore += typeRiskMap[type] || 1;
    
    // 根据金额评估风险
    if (value) {
      const ethValue = parseFloat(this.formatWei(value));
      if (ethValue > 10) riskScore += 2;
      else if (ethValue > 1) riskScore += 1;
    }
    
    // 特殊参数风险评估
    if (type === 'approve' && params && params.amount === '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff') {
      riskScore += 2; // 无限授权风险更高
    }
    
    // 映射风险分数到风险等级
    if (riskScore >= 5) return '高风险';
    if (riskScore >= 3) return '中风险';
    return '低风险';
  },
  
  // 格式化交易参数
  formatParams(params) {
    if (!params || typeof params !== 'object') {
      return [];
    }
    
    return Object.entries(params).map(([key, value]) => ({
      name: key,
      value: this.formatParamValue(value),
      type: this.detectParamType(value)
    }));
  },
  
  // 格式化参数值
  formatParamValue(value) {
    if (typeof value === 'string' && value.length > 42 && this.isHexString(value)) {
      // 长十六进制字符串可能是地址或哈希
      if (value.length === 42) return value; // 地址
      return `${value.substring(0, 10)}...${value.substring(value.length - 6)}`;
    }
    
    if (typeof value === 'string' && value.length > 50) {
      // 太长的字符串进行截断
      return `${value.substring(0, 50)}...`;
    }
    
    return value.toString();
  },
  
  // 检测参数类型
  detectParamType(value) {
    if (this.isAddress(value)) return 'address';
    if (this.isHexString(value)) return 'hex';
    if (!isNaN(value)) return 'number';
    return 'string';
  },
  
  // 检查是否为有效的以太坊地址
  isAddress(value) {
    try {
      const ethers = window.ethers || require('ethers');
      return ethers.utils.isAddress(value);
    } catch (error) {
      // 简易地址验证
      return /^0x[0-9a-fA-F]{40}$/.test(value);
    }
  },
  
  // 检查是否为十六进制字符串
  isHexString(value) {
    return /^0x[0-9a-fA-F]*$/.test(value);
  }
};

// React组件：交易确认对话框
function TransactionConfirmationDialog({ transaction, onConfirm, onCancel }) {
  const details = TransactionDisplayer.formatTransactionDetails(transaction);
  
  return (
    <div className="transaction-confirmation-modal">
      <h3>确认交易</h3>
      
      <div className="transaction-type">
        <span className={`risk-indicator ${details.riskLevel === '高风险' ? 'high' : details.riskLevel === '中风险' ? 'medium' : 'low'}`}>
          {details.riskLevel}
        </span>
        <h4>{details.type}</h4>
      </div>
      
      <div className="transaction-details">
        <div className="detail-row">
          <span className="label">合约地址</span>
          <span className="value mono">{details.contract}</span>
        </div>
        
        {details.token && (
          <div className="detail-row">
            <span className="label">代币</span>
            <span className="value">{details.token}</span>
          </div>
        )}
        
        <div className="detail-row">
          <span className="label">函数</span>
          <span className="value mono">{details.function}</span>
        </div>
        
        <div className="detail-row">
          <span className="label">金额</span>
          <span className="value">{details.value}</span>
        </div>
        
        <div className="detail-row">
          <span className="label">Gas设置</span>
          <span className="value mono">{details.gas}</span>
        </div>
        
        <div className="detail-row cost">
          <span className="label">预估成本</span>
          <span className="value highlight">{details.estimatedCost}</span>
        </div>
      </div>
      
      {details.params.length > 0 && (
        <div className="transaction-params">
          <h5>函数参数</h5>
          {details.params.map((param, index) => (
            <div key={index} className="param-row">
              <span className="param-name">{param.name}:</span>
              <span className={`param-value ${param.type}`}>{param.value}</span>
            </div>
          ))}
        </div>
      )}
      
      {details.riskLevel === '高风险' && (
        <div className="risk-warning">
          ⚠️ 警告：这是一笔高风险交易，请仔细检查所有参数，确认您了解交易的全部后果。
        </div>
      )}
      
      <div className="confirmation-buttons">
        <button onClick={onCancel} className="cancel-btn">取消</button>
        <button onClick={onConfirm} className={`confirm-btn ${details.riskLevel === '高风险' ? 'high-risk' : ''}`}>
          确认交易
        </button>
      </div>
    </div>
  );
}

1.3 代码隔离与沙盒执行原则

将智能合约交互代码与UI渲染代码分离，并在安全的环境中执行敏感操作。

// 智能合约交互沙盒
class ContractInteractionSandbox {
  constructor() {
    this.allowedContracts = new Map(); // 白名单合约
    this.maxGasLimit = 5000000; // 设置最大gas限制
    this.maxGasPrice = 100; // gwei，防止过高的gas价格
    this.transactionQueue = []; // 交易队列
    this.isProcessing = false; // 是否正在处理交易
  }
  
  // 添加合约到白名单
  addAllowedContract(contractAddress, contractAbi, contractName) {
    if (!this.isValidAddress(contractAddress)) {
      throw new Error('无效的合约地址');
    }
    
    this.allowedContracts.set(contractAddress.toLowerCase(), {
      abi: contractAbi,
      name: contractName || `Contract_${contractAddress.substring(0, 6)}`
    });
    
    console.log(`已将合约添加到白名单: ${contractName || contractAddress}`);
  }
  
  // 验证合约是否在白名单中
  isContractAllowed(contractAddress) {
    return this.allowedContracts.has(contractAddress.toLowerCase());
  }
  
  // 获取合约信息
  getContractInfo(contractAddress) {
    return this.allowedContracts.get(contractAddress.toLowerCase());
  }
  
  // 安全执行合约调用（只读操作）
  async safeCall(provider, contractAddress, functionName, params = []) {
    try {
      // 验证合约是否在白名单中
      if (!this.isContractAllowed(contractAddress)) {
        throw new Error(`合约不在白名单中: ${contractAddress}`);
      }
      
      const contractInfo = this.getContractInfo(contractAddress);
      
      // 创建合约实例
      const contract = new provider.eth.Contract(contractInfo.abi, contractAddress);
      
      // 执行合约调用
      const result = await contract.methods[functionName](...params).call();
      
      // 记录调用日志
      this.logContractCall('read', contractAddress, functionName, params, result);
      
      return result;
    } catch (error) {
      console.error(`安全合约调用失败 [${functionName}]:`, error);
      throw new Error(`合约读取调用失败: ${error.message}`);
    }
  }
  
  // 安全执行合约交易（写入操作）
  async safeSend(signer, contractAddress, functionName, params = [], options = {}) {
    try {
      // 验证合约是否在白名单中
      if (!this.isContractAllowed(contractAddress)) {
        throw new Error(`合约不在白名单中: ${contractAddress}`);
      }
      
      // 验证签名者是否有效
      if (!signer || !signer.getAddress) {
        throw new Error('无效的签名者');
      }
      
      // 获取用户地址进行额外验证
      const userAddress = await signer.getAddress();
      
      // 验证交易选项
      const validatedOptions = this.validateTransactionOptions(options);
      
      // 获取合约信息
      const contractInfo = this.getContractInfo(contractAddress);
      
      // 创建合约实例
      const contract = new signer.eth.Contract(contractInfo.abi, contractAddress);
      
      // 准备交易
      const tx = contract.methods[functionName](...params);
      
      // 估算gas
      const gasEstimate = await tx.estimateGas({ from: userAddress, ...validatedOptions });
      
      // 确保估算的gas不超过最大限制
      if (gasEstimate > this.maxGasLimit) {
        throw new Error(`估算的gas超过最大限制: ${gasEstimate} > ${this.maxGasLimit}`);
      }
      
      // 添加gas缓冲
      const safeGasLimit = Math.min(Math.floor(gasEstimate * 1.2), this.maxGasLimit);
      
      // 发送交易
      const transaction = await tx.send({
        from: userAddress,
        gas: safeGasLimit,
        ...validatedOptions
      });
      
      // 记录交易日志
      this.logContractTransaction(contractAddress, functionName, params, validatedOptions, transaction);
      
      return transaction;
    } catch (error) {
      console.error(`安全合约交易失败 [${functionName}]:`, error);
      // 增强错误信息
      const enhancedError = this.enhanceContractError(error);
      throw enhancedError;
    }
  }
  
  // 验证交易选项
  validateTransactionOptions(options) {
    const validated = { ...options };
    
    // 验证并限制gas价格
    if (validated.gasPrice) {
      const gasPrice = parseInt(validated.gasPrice);
      if (gasPrice > this.maxGasPrice * 1e9) { // 转换为wei
        validated.gasPrice = this.maxGasPrice * 1e9;
        console.warn(`Gas价格过高，已调整为最大限制: ${this.maxGasPrice} gwei`);
      }
    }
    
    // 验证并限制gas限制
    if (validated.gas) {
      const gasLimit = parseInt(validated.gas);
      if (gasLimit > this.maxGasLimit) {
        validated.gas = this.maxGasLimit;
        console.warn(`Gas限制过高，已调整为最大限制: ${this.maxGasLimit}`);
      }
    }
    
    // 验证value参数（如果存在）
    if (validated.value) {
      const value = parseInt(validated.value);
      if (isNaN(value) || value < 0) {
        throw new Error('无效的交易金额');
      }
    }
    
    return validated;
  }
  
  // 增强合约错误信息
  enhanceContractError(error) {
    let enhancedMessage = error.message;
    
    // 常见错误模式匹配
    if (error.message.includes('User denied transaction signature')) {
      enhancedMessage = '用户取消了交易签名';
    } else if (error.message.includes('out of gas')) {
      enhancedMessage = '交易gas不足，可能是因为操作过于复杂或gas价格设置过低';
    } else if (error.message.includes('reverted')) {
      enhancedMessage = '交易已回滚，可能是因为合约执行条件不满足';
    }
    
    const enhancedError = new Error(enhancedMessage);
    enhancedError.originalError = error;
    
    return enhancedError;
  }
  
  // 加入交易队列
  queueTransaction(transaction) {
    return new Promise((resolve, reject) => {
      this.transactionQueue.push({
        transaction,
        resolve,
        reject,
        timestamp: Date.now()
      });
      
      // 如果当前没有处理交易，开始处理
      if (!this.isProcessing) {
        this.processTransactionQueue();
      }
    });
  }
  
  // 处理交易队列
  async processTransactionQueue() {
    if (this.isProcessing || this.transactionQueue.length === 0) {
      return;
    }
    
    this.isProcessing = true;
    
    while (this.transactionQueue.length > 0) {
      const queueItem = this.transactionQueue.shift();
      const { transaction, resolve, reject } = queueItem;
      
      try {
        // 添加交易延迟，防止用户误操作快速连续交易
        await this.delay(1000);
        
        const result = await this.executeQueuedTransaction(transaction);
        resolve(result);
      } catch (error) {
        reject(error);
      }
    }
    
    this.isProcessing = false;
  }
  
  // 执行队列中的交易
  async executeQueuedTransaction(transaction) {
    const { signer, contractAddress, functionName, params, options } = transaction;
    
    // 执行安全交易
    return this.safeSend(signer, contractAddress, functionName, params, options);
  }
  
  // 延迟函数
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  
  // 记录合约调用日志
  logContractCall(type, contractAddress, functionName, params, result) {
    console.log(`[Contract Call] ${type} - ${contractAddress} - ${functionName}`, {
      params,
      result,
      timestamp: new Date().toISOString()
    });
    
    // 在实际应用中，这里可以将日志发送到服务器进行分析
  }
  
  // 记录合约交易日志
  logContractTransaction(contractAddress, functionName, params, options, transaction) {
    console.log(`[Contract Transaction] ${contractAddress} - ${functionName}`, {
      params,
      options,
      transactionHash: transaction.transactionHash,
      blockNumber: transaction.blockNumber,
      timestamp: new Date().toISOString()
    });
    
    // 在实际应用中，这里可以将日志发送到服务器进行分析和监控
  }
  
  // 验证地址是否有效
  isValidAddress(address) {
    try {
      const ethers = window.ethers || require('ethers');
      return ethers.utils.isAddress(address);
    } catch (error) {
      // 简易地址验证
      return /^0x[0-9a-fA-F]{40}$/.test(address);
    }
  }
}

// 使用示例：初始化并使用合约交互沙盒
function setupContractSandbox() {
  // 创建沙盒实例
  const sandbox = new ContractInteractionSandbox();
  
  // 添加白名单合约
  sandbox.addAllowedContract(
    '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D', // Uniswap V2 Router
    uniswapRouterAbi, // 此处应填入实际的ABI
    'Uniswap Router'
  );
  
  sandbox.addAllowedContract(
    '0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT 合约
    erc20Abi, // 此处应填入实际的ABI
    'USDT Token'
  );
  
  return sandbox;
}

// 使用沙盒执行安全的代币转账
async function safeTokenTransfer(sandbox, signer, tokenAddress, toAddress, amount) {
  try {
    // 加入交易队列，确保顺序执行
    const transaction = await sandbox.queueTransaction({
      signer,
      contractAddress: tokenAddress,
      functionName: 'transfer',
      params: [toAddress, amount],
      options: {}
    });
    
    console.log('代币转账成功:', transaction.transactionHash);
    return transaction;
  } catch (error) {
    console.error('代币转账失败:', error);
    throw error;
  }
}

二、智能合约交互的常见风险

2.1 恶意合约风险

恶意合约可能包含隐藏的后门或逻辑漏洞，导致用户资产损失。

// 恶意合约检测器
const MaliciousContractDetector = {
  // 已知的恶意合约地址库
  knownMaliciousContracts: new Set([
    '0xBadContract1234567890123456789012345678901234',
    '0xScamContract1234567890123456789012345678901234',
    // 更多已知恶意合约地址...
  ]),
  
  // 恶意合约特征库
  maliciousPatterns: [
    // 自我销毁函数模式
    /selfdestruct\s*\(/i,
    // 隐藏的转账函数模式
    /transfer\s*\(\s*address\s+\w+,\s*\w+\s*\)/i,
    // 无限铸币模式
    /mint\s*\(\s*address\s+\w+,\s*\w+\s*\)/i,
    // 管理员特权模式
    /onlyOwner\s*\(/i,
    // 可修改参数模式
    /changeParameter\s*\(/i
  ],
  
  // 检查合约是否在已知恶意合约列表中
  isKnownMalicious(contractAddress) {
    return this.knownMaliciousContracts.has(contractAddress.toLowerCase());
  },
  
  // 从合约ABI中检测潜在的恶意模式
  detectMaliciousPatternsInABI(contractABI) {
    const findings = [];
    
    if (!Array.isArray(contractABI)) {
      return findings;
    }
    
    contractABI.forEach(item => {
      if (item.type === 'function') {
        // 检查函数名是否可疑
        if (this.isSuspiciousFunctionName(item.name)) {
          findings.push({
            type: 'suspicious_function_name',
            functionName: item.name,
            description: `函数名称可能包含风险操作`
          });
        }
        
        // 检查函数参数是否可疑
        if (this.hasSuspiciousParameters(item.inputs)) {
          findings.push({
            type: 'suspicious_parameters',
            functionName: item.name,
            description: `函数包含可疑参数`
          });
        }
        
        // 检查函数是否有管理员权限
        if (this.hasAdminAccessControl(item)) {
          findings.push({
            type: 'admin_function',
            functionName: item.name,
            description: `函数可能具有管理员权限`
          });
        }
      }
    });
    
    return findings;
  },
  
  // 检查函数名是否可疑
  isSuspiciousFunctionName(functionName) {
    const suspiciousKeywords = [
      'kill', 'destroy', 'suicide', 'selfdestruct',
      'drain', 'withdrawAll', 'transferAll', 'steal',
      'change', 'set', 'override', 'migrate',
      'upgrade', 'emergency', 'rescue', 'reset'
    ];
    
    const lowerName = functionName.toLowerCase();
    return suspiciousKeywords.some(keyword => lowerName.includes(keyword));
  },
  
  // 检查函数参数是否可疑
  hasSuspiciousParameters(inputs) {
    if (!Array.isArray(inputs)) {
      return false;
    }
    
    // 检查是否有地址类型的参数（可能用于转移资金）
    const hasAddressParam = inputs.some(input => 
      input.type === 'address' || input.internalType === 'address'
    );
    
    // 检查是否有金额类型的参数（可能用于提取资金）
    const hasAmountParam = inputs.some(input => 
      ['uint256', 'uint', 'int256', 'int'].includes(input.type) ||
      ['uint256', 'uint', 'int256', 'int'].includes(input.internalType)
    );
    
    return hasAddressParam && hasAmountParam;
  },
  
  // 检查函数是否有管理员权限控制
  hasAdminAccessControl(functionInfo) {
    // 检查修饰器是否包含管理员控制
    if (functionInfo.modifiers) {
      return functionInfo.modifiers.some(modifier => 
        modifier.toLowerCase().includes('onlyowner') ||
        modifier.toLowerCase().includes('admin') ||
        modifier.toLowerCase().includes('authorize')
      );
    }
    
    // 检查函数名是否包含管理员关键词
    if (functionInfo.name) {
      return this.isSuspiciousFunctionName(functionInfo.name);
    }
    
    return false;
  },
  
  // 分析合约字节码查找可疑模式
  async analyzeContractBytecode(provider, contractAddress) {
    try {
      // 获取合约字节码
      const bytecode = await this.getContractBytecode(provider, contractAddress);
      
      // 转换为字符串以便分析
      const bytecodeStr = bytecode.toLowerCase();
      
      // 存储检测到的可疑模式
      const suspiciousPatterns = [];
      
      // 检查自我销毁指令
      if (bytecodeStr.includes('733078')) { // SELFDESTRUCT 操作码的部分模式
        suspiciousPatterns.push('合约可能包含自我销毁功能');
      }
      
      // 检查 delegatecall 指令
      if (bytecodeStr.includes('f4')) { // DELEGATECALL 操作码
        suspiciousPatterns.push('合约可能使用 delegatecall，存在潜在风险');
      }
      
      // 检查 call 指令（尤其是调用外部合约的模式）
      if (bytecodeStr.includes('f1')) { // CALL 操作码
        suspiciousPatterns.push('合约可能调用外部合约，存在交互风险');
      }
      
      return suspiciousPatterns;
    } catch (error) {
      console.error('分析合约字节码失败:', error);
      return [];
    }
  },
  
  // 获取合约字节码
  async getContractBytecode(provider, contractAddress) {
    try {
      if (provider && provider.getCode) {
        return await provider.getCode(contractAddress);
      } else {
        throw new Error('无效的provider');
      }
    } catch (error) {
      console.error('获取合约字节码失败:', error);
      throw error;
    }
  },
  
  // 评估合约整体风险
  async assessContractRisk(provider, contractAddress) {
    try {
      // 检查是否是已知的恶意合约
      if (this.isKnownMalicious(contractAddress)) {
        return {
          riskLevel: '高风险',
          reasons: ['合约在已知恶意合约列表中'],
          recommendation: '立即停止与该合约的所有交互'
        };
      }
      
      // 分析合约字节码
      const bytecodePatterns = await this.analyzeContractBytecode(provider, contractAddress);
      
      // 构建风险评估结果
      let riskLevel = '低风险';
      const reasons = [...bytecodePatterns];
      
      // 根据检测到的模式确定风险等级
      if (reasons.length === 0) {
        riskLevel = '低风险';
      } else if (reasons.length === 1) {
        riskLevel = '中风险';
      } else {
        riskLevel = '高风险';
      }
      
      // 生成建议
      let recommendation = '在继续交互前，建议仔细审查合约代码';
      if (riskLevel === '高风险') {
        recommendation = '强烈建议不要与该合约交互，除非您完全了解其中的风险';
      }
      
      return {
        riskLevel,
        reasons,
        recommendation
      };
    } catch (error) {
      console.error('评估合约风险失败:', error);
      return {
        riskLevel: '未知风险',
        reasons: ['无法评估合约风险'],
        recommendation: '谨慎与该合约交互'
      };
    }
  },
  
  // 验证合约交互安全性
  async validateContractInteraction(provider, contractAddress, functionName, params) {
    try {
      // 检查是否是已知的恶意合约
      if (this.isKnownMalicious(contractAddress)) {
        return {
          isValid: false,
          reason: '合约在已知恶意合约列表中',
          critical: true
        };
      }
      
      // 检查函数名是否包含高风险操作
      if (this.isSuspiciousFunctionName(functionName)) {
        return {
          isValid: false,
          reason: `函数 "${functionName}" 包含高风险操作`,
          critical: true
        };
      }
      
      // 检查参数是否包含敏感操作
      if (this.containsSensitiveParams(params)) {
        return {
          isValid: false,
          reason: '参数包含敏感操作',
          critical: true
        };
      }
      
      // 默认验证通过
      return {
        isValid: true,
        reason: '合约交互验证通过'
      };
    } catch (error) {
      console.error('验证合约交互安全性失败:', error);
      return {
        isValid: false,
        reason: '无法验证合约交互安全性',
        critical: false
      };
    }
  },
  
  // 检查参数是否包含敏感操作
  containsSensitiveParams(params) {
    if (!Array.isArray(params)) {
      return false;
    }
    
    // 检查是否包含地址类型的参数
    const hasAddressParam = params.some(param => 
      typeof param === 'string' && param.startsWith('0x') && param.length === 42
    );
    
    // 检查是否包含大额数值
    const hasLargeAmount = params.some(param => 
      typeof param === 'number' && param > 1000000 ||
      (typeof param === 'string' && !isNaN(param) && parseFloat(param) > 1000000)
    );
    
    return hasAddressParam && hasLargeAmount;
  }
};

// 使用示例：验证合约交互安全性
async function verifyContractInteractionSafety(provider, contractAddress, functionName, params) {
  try {
    const detector = MaliciousContractDetector;
    
    // 验证合约交互安全性
    const validationResult = await detector.validateContractInteraction(
      provider, contractAddress, functionName, params
    );
    
    if (!validationResult.isValid) {
      console.warn(`合约交互验证失败: ${validationResult.reason}`);
      
      if (validationResult.critical) {
        throw new Error(`高风险合约交互已被阻止: ${validationResult.reason}`);
      }
      
      // 对于非高风险警告，可以提示用户但允许继续
      showContractInteractionWarning(validationResult.reason);
    }
    
    // 进行完整的合约风险评估
    const riskAssessment = await detector.assessContractRisk(provider, contractAddress);
    
    if (riskAssessment.riskLevel === '高风险') {
      throw new Error(`合约评估为高风险，请谨慎交互`);
    }
    
    console.log(`合约交互安全验证通过，风险等级: ${riskAssessment.riskLevel}`);
    return true;
  } catch (error) {
    console.error('合约交互安全验证失败:', error);
    throw error;
  }
}

// 显示合约交互警告
function showContractInteractionWarning(message) {
  // 在实际应用中，这里应该显示用户友好的警告界面
  console.warn('合约交互警告:', message);
  
  // 例如，在React应用中显示警告模态框
  // showWarningModal({
  //   title: '合约交互警告',
  //   message: message,
  //   confirmText: '继续',
  //   cancelText: '取消'
  // });
}

2.2 授权风险

无限授权或过度授权是Web3应用中常见的安全风险，可能导致用户资产被恶意合约转移。

// 授权安全管理器
const ApprovalSecurityManager = {
  // 最大推荐授权金额（以代币最小单位计）
  MAX_RECOMMENDED_APPROVAL: 1000000,
  
  // 无限授权标记
  INFINITE_APPROVAL: '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
  
  // 检查授权金额是否安全
  isApprovalAmountSafe(amount, tokenDecimals = 18, isInfinite = false) {
    // 检查是否是无限授权
    if (isInfinite || amount === this.INFINITE_APPROVAL) {
      return { 
        isSafe: false, 
        reason: '不建议使用无限授权',
        recommendedAmount: this.calculateSafeApprovalAmount(tokenDecimals)
      };
    }
    
    // 转换为可读金额
    const readableAmount = this.convertToReadableAmount(amount, tokenDecimals);
    
    // 检查是否超过最大推荐授权金额
    if (readableAmount > this.MAX_RECOMMENDED_APPROVAL) {
      return { 
        isSafe: false, 
        reason: `授权金额过大 (${readableAmount} > ${this.MAX_RECOMMENDED_APPROVAL})`,
        recommendedAmount: this.calculateSafeApprovalAmount(tokenDecimals)
      };
    }
    
    return { isSafe: true };
  },
  
  // 计算安全的授权金额
  calculateSafeApprovalAmount(tokenDecimals = 18, multiplier = 1.2) {
    // 基于用户当前余额计算安全的授权金额
    // 简化实现：返回最大推荐授权金额
    return this.convertToTokenUnits(this.MAX_RECOMMENDED_APPROVAL, tokenDecimals);
  },
  
  // 转换为可读金额
  convertToReadableAmount(amount, decimals) {
    try {
      // 使用ethers.js或web3.js的转换功能
      const ethers = window.ethers || require('ethers');
      return parseFloat(ethers.utils.formatUnits(amount.toString(), decimals));
    } catch (error) {
      // 备用简单转换
      return parseInt(amount) / Math.pow(10, decimals);
    }
  },
  
  // 转换为代币最小单位
  convertToTokenUnits(amount, decimals) {
    try {
      // 使用ethers.js或web3.js的转换功能
      const ethers = window.ethers || require('ethers');
      return ethers.utils.parseUnits(amount.toString(), decimals).toString();
    } catch (error) {
      // 备用简单转换
      return (parseFloat(amount) * Math.pow(10, decimals)).toString();
    }
  },
  
  // 获取当前授权状态
  async getCurrentApproval(provider, tokenAddress, ownerAddress, spenderAddress) {
    try {
      // 创建ERC20代币合约实例
      const tokenContract = new provider.eth.Contract(erc20Abi, tokenAddress); // 此处应填入实际的ERC20 ABI
      
      // 调用allowance函数获取当前授权金额
      const allowance = await tokenContract.methods.allowance(ownerAddress, spenderAddress).call();
      
      return allowance;
    } catch (error) {
      console.error('获取当前授权状态失败:', error);
      throw error;
    }
  },
  
  // 检查是否需要更新授权
  async checkAndUpdateApproval(signer, tokenAddress, spenderAddress, requiredAmount, tokenDecimals = 18) {
    try {
      // 获取签名者地址
      const ownerAddress = await signer.getAddress();
      const provider = signer.provider;
      
      // 获取当前授权金额
      const currentApproval = await this.getCurrentApproval(provider, tokenAddress, ownerAddress, spenderAddress);
      
      // 转换为可读金额进行比较
      const currentApprovalReadable = this.convertToReadableAmount(currentApproval, tokenDecimals);
      const requiredAmountReadable = requiredAmount;
      
      // 如果当前授权金额足够，则不需要更新
      if (currentApprovalReadable >= requiredAmountReadable) {
        console.log(`当前授权金额足够 (${currentApprovalReadable} >= ${requiredAmountReadable})`);
        return { updated: false };
      }
      
      // 计算需要增加的授权金额
      const additionalAmount = requiredAmountReadable - currentApprovalReadable;
      
      // 检查增加的授权金额是否安全
      const safeAmount = this.isApprovalAmountSafe(
        this.convertToTokenUnits(additionalAmount, tokenDecimals),
        tokenDecimals
      );
      
      // 如果不安全，使用推荐金额
      const approvalAmount = safeAmount.isSafe ? 
        this.convertToTokenUnits(additionalAmount, tokenDecimals) : 
        safeAmount.recommendedAmount;
      
      // 执行授权更新
      await this.updateApproval(signer, tokenAddress, spenderAddress, approvalAmount);
      
      console.log(`已更新授权金额: ${approvalAmount}`);
      return { updated: true, amount: approvalAmount };
    } catch (error) {
      console.error('检查并更新授权失败:', error);
      throw error;
    }
  },
  
  // 更新授权金额
  async updateApproval(signer, tokenAddress, spenderAddress, amount) {
    try {
      // 创建ERC20代币合约实例
      const tokenContract = new signer.eth.Contract(erc20Abi, tokenAddress); // 此处应填入实际的ERC20 ABI
      
      // 调用approve函数更新授权金额
      const tx = await tokenContract.methods.approve(spenderAddress, amount).send({
        from: await signer.getAddress()
      });
      
      return tx;
    } catch (error) {
      console.error('更新授权失败:', error);
      throw error;
    }
  },
  
  // 撤销授权
  async revokeApproval(signer, tokenAddress, spenderAddress) {
    try {
      // 将授权金额设置为0来撤销授权
      return await this.updateApproval(signer, tokenAddress, spenderAddress, '0');
    } catch (error) {
      console.error('撤销授权失败:', error);
      throw error;
    }
  },
  
  // 监控用户所有授权
  async monitorAllApprovals(provider, ownerAddress) {
    try {
      // 注意：这需要区块链浏览器API或索引服务的支持
      // 简化实现：返回模拟数据
      
      // 实际应用中，应调用如Etherscan API等获取用户的所有授权
      console.warn('监控所有授权功能需要区块链浏览器API支持');
      
      // 返回模拟数据
      return [
        {
          tokenAddress: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
          tokenName: 'Tether USD',
          tokenSymbol: 'USDT',
          spenderAddress: '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D',
          spenderName: 'Uniswap Router',
          amount: '1000000000000000000000',
          isInfinite: false
        },
        {
          tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
          tokenName: 'USD Coin',
          tokenSymbol: 'USDC',
          spenderAddress: '0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F',
          spenderName: 'SushiSwap Router',
          amount: '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
          isInfinite: true
        }
      ];
    } catch (error) {
      console.error('监控所有授权失败:', error);
      throw error;
    }
  },
  
  // 生成授权风险报告
  async generateApprovalRiskReport(provider, ownerAddress) {
    try {
      // 获取所有授权
      const approvals = await this.monitorAllApprovals(provider, ownerAddress);
      
      const riskReport = {
        totalApprovals: approvals.length,
        highRiskApprovals: [],
        recommendations: []
      };
      
      // 分析每个授权的风险
      for (const approval of approvals) {
        // 检查是否是无限授权
        if (approval.isInfinite) {
          riskReport.highRiskApprovals.push({
            ...approval,
            riskReason: '无限授权存在高风险'
          });
          
          riskReport.recommendations.push({
            action: '撤销并重新授权有限金额',
            tokenSymbol: approval.tokenSymbol,
            spenderName: approval.spenderName
          });
        }
      }
      
      return riskReport;
    } catch (error) {
      console.error('生成授权风险报告失败:', error);
      throw error;
    }
  }
};

// React组件：授权管理界面
function ApprovalManager({ provider, signer }) {
  const [approvals, setApprovals] = useState([]);
  const [loading, setLoading] = useState(false);
  const [riskReport, setRiskReport] = useState(null);
  
  // 加载用户授权列表
  const loadUserApprovals = async () => {
    try {
      setLoading(true);
      
      // 获取签名者地址
      const ownerAddress = await signer.getAddress();
      
      // 获取所有授权
      const userApprovals = await ApprovalSecurityManager.monitorAllApprovals(provider, ownerAddress);
      setApprovals(userApprovals);
      
      // 生成风险报告
      const report = await ApprovalSecurityManager.generateApprovalRiskReport(provider, ownerAddress);
      setRiskReport(report);
    } catch (error) {
      console.error('加载用户授权失败:', error);
      showError('加载授权列表失败，请重试');
    } finally {
      setLoading(false);
    }
  };
  
  // 撤销授权
  const handleRevokeApproval = async (tokenAddress, spenderAddress, tokenSymbol, spenderName) => {
    try {
      if (!window.confirm(`确定要撤销对 ${spenderName} 的 ${tokenSymbol} 授权吗？`)) {
        return;
      }
      
      setLoading(true);
      
      // 撤销授权
      await ApprovalSecurityManager.revokeApproval(signer, tokenAddress, spenderAddress);
      
      showSuccess(`已成功撤销对 ${spenderName} 的 ${tokenSymbol} 授权`);
      
      // 重新加载授权列表
      await loadUserApprovals();
    } catch (error) {
      console.error('撤销授权失败:', error);
      showError('撤销授权失败，请重试');
    } finally {
      setLoading(false);
    }
  };
  
  // 重新授权有限金额
  const handleReapproveLimited = async (tokenAddress, spenderAddress, tokenSymbol, spenderName) => {
    try {
      // 获取用户输入的授权金额
      const amount = window.prompt(`请输入要授权给 ${spenderName} 的 ${tokenSymbol} 数量：`);
      
      if (!amount || isNaN(amount) || parseFloat(amount) <= 0) {
        showError('请输入有效的授权金额');
        return;
      }
      
      setLoading(true);
      
      // 转换为代币最小单位
      const amountInUnits = ApprovalSecurityManager.convertToTokenUnits(amount, 18); // 假设18位小数
      
      // 执行授权
      await ApprovalSecurityManager.updateApproval(signer, tokenAddress, spenderAddress, amountInUnits);
      
      showSuccess(`已成功授权 ${amount} ${tokenSymbol} 给 ${spenderName}`);
      
      // 重新加载授权列表
      await loadUserApprovals();
    } catch (error) {
      console.error('重新授权失败:', error);
      showError('重新授权失败，请重试');
    } finally {
      setLoading(false);
    }
  };
  
  // 组件加载时获取授权列表
  useEffect(() => {
    if (provider && signer) {
      loadUserApprovals();
    }
  }, [provider, signer]);
  
  return (
    <div className="approval-manager">
      <h2>授权管理</h2>
      
      {riskReport && riskReport.highRiskApprovals.length > 0 && (
        <div className="risk-warning">
          ⚠️ 您有 {riskReport.highRiskApprovals.length} 项高风险授权需要注意
        </div>
      )}
      
      {loading ? (
        <div className="loading">加载中...</div>
      ) : approvals.length > 0 ? (
        <table className="approvals-table">
          <thead>
            <tr>
              <th>代币</th>
              <th>授权给</th>
              <th>授权金额</th>
              <th>状态</th>
              <th>操作</th>
            </tr>
          </thead>
          <tbody>
            {approvals.map((approval, index) => (
              <tr key={index} className={approval.isInfinite ? 'high-risk' : ''}>
                <td>
                  <div className="token-info">
                    <span className="token-symbol">{approval.tokenSymbol}</span>
                    <span className="token-name">{approval.tokenName}</span>
                  </div>
                </td>
                <td>
                  <div className="spender-info">
                    <span className="spender-name">{approval.spenderName}</span>
                    <span className="spender-address">{approval.spenderAddress.substring(0, 8)}...</span>
                  </div>
                </td>
                <td className={approval.isInfinite ? 'infinite-amount' : ''}>
                  {approval.isInfinite ? '无限授权' : 
                    ApprovalSecurityManager.convertToReadableAmount(approval.amount, 18)}
                </td>
                <td>
                  <span className={`status-badge ${approval.isInfinite ? 'high-risk' : 'normal'}`}>
                    {approval.isInfinite ? '高风险' : '正常'}
                  </span>
                </td>
                <td>
                  <div className="action-buttons">
                    <button onClick={() => handleRevokeApproval(
                      approval.tokenAddress, 
                      approval.spenderAddress, 
                      approval.tokenSymbol, 
                      approval.spenderName
                    )}>
                      撤销授权
                    </button>
                    {approval.isInfinite && (
                      <button onClick={() => handleReapproveLimited(
                        approval.tokenAddress, 
                        approval.spenderAddress, 
                        approval.tokenSymbol, 
                        approval.spenderName
                      )}>
                        重新授权有限金额
                      </button>
                    )}
                  </div>
                </td>
              </tr>
            ))}
          </tbody>
        </table>
      ) : (
        <div className="empty-state">
          您当前没有任何授权记录
        </div>
      )}
    </div>
  );
}

2.3 重入攻击风险

重入攻击是一种常见的智能合约攻击方式，攻击者通过递归调用合约函数来窃取资金。

// 重入攻击防护工具
const ReentrancyProtection = {
  // 合约调用状态跟踪
  contractCallStates: new Map(),
  
  // 最大递归调用深度
  MAX_RECURSION_DEPTH: 3,
  
  // 检查合约是否可能存在重入风险
  assessReentrancyRisk(contractABI, functionName) {
    const riskAssessment = {
      hasRisk: false,
      riskLevel: '低风险',
      reasons: []
    };
    
    if (!Array.isArray(contractABI)) {
      return riskAssessment;
    }
    
    // 查找目标函数
    const targetFunction = contractABI.find(item => 
      item.type === 'function' && item.name === functionName
    );
    
    if (!targetFunction) {
      return riskAssessment;
    }
    
    // 检查函数是否处理资金（payable或涉及转账）
    const handlesFunds = targetFunction.payable || 
                        this.functionHandlesFunds(contractABI, functionName);
    
    if (handlesFunds) {
      riskAssessment.hasRisk = true;
      riskAssessment.riskLevel = '中风险';
      riskAssessment.reasons.push('函数处理资金，可能存在重入风险');
    }
    
    // 检查函数是否调用外部合约
    const callsExternalContract = this.functionCallsExternalContract(contractABI, functionName);
    
    if (callsExternalContract) {
      riskAssessment.hasRisk = true;
      riskAssessment.riskLevel = '高风险';
      riskAssessment.reasons.push('函数调用外部合约，存在重入风险');
    }
    
    return riskAssessment;
  },
  
  // 检查函数是否处理资金
  functionHandlesFunds(contractABI, functionName) {
    // 简化实现：检查函数名是否包含资金相关关键词
    const fundKeywords = ['transfer', 'withdraw', 'deposit', 'send', 'claim', 'reward'];
    
    return fundKeywords.some(keyword => 
      functionName.toLowerCase().includes(keyword.toLowerCase())
    );
  },
  
  // 检查函数是否调用外部合约
  functionCallsExternalContract(contractABI, functionName) {
    // 简化实现：检查函数名是否包含外部调用相关关键词
    const externalCallKeywords = ['call', 'delegatecall', 'send', 'transfer', 'approve'];
    
    return externalCallKeywords.some(keyword => 
      functionName.toLowerCase().includes(keyword.toLowerCase())
    );
  },
  
  // 开始合约调用（设置防重入锁）
  startContractCall(contractAddress, functionName) {
    const key = `${contractAddress}:${functionName}`;
    let callState = this.contractCallStates.get(key);
    
    if (!callState) {
      callState = {
        callCount: 0,
        lastCallTime: Date.now()
      };
    }
    
    callState.callCount++;
    callState.lastCallTime = Date.now();
    
    // 检查调用深度是否超过限制
    if (callState.callCount > this.MAX_RECURSION_DEPTH) {
      console.warn(`检测到可能的重入攻击：${key} 调用深度 ${callState.callCount}`);
      return { allowed: false, reason: '调用深度超过安全限制' };
    }
    
    this.contractCallStates.set(key, callState);
    
    return { allowed: true, callId: key, callCount: callState.callCount };
  },
  
  // 结束合约调用（释放防重入锁）
  endContractCall(callId) {
    const callState = this.contractCallStates.get(callId);
    
    if (callState) {
      callState.callCount--;
      
      // 如果调用计数为0，清除状态
      if (callState.callCount <= 0) {
        this.contractCallStates.delete(callId);
      } else {
        this.contractCallStates.set(callId, callState);
      }
    }
  },
  
  // 包装合约调用以添加防重入保护
  async safeContractCall(signer, contractAddress, functionName, params = [], options = {}) {
    try {
      // 检查重入风险
      const riskAssessment = this.assessReentrancyRisk(null, functionName); // 假设我们没有完整的ABI
      
      if (riskAssessment.hasRisk) {
        console.warn(`警告：调用函数 "${functionName}" 存在潜在的重入风险`);
        
        // 对于高风险调用，显示额外警告
        if (riskAssessment.riskLevel === '高风险') {
          const userConfirmed = window.confirm(
            `警告：此操作可能存在安全风险。\n` +
            `风险原因：${riskAssessment.reasons.join('\n')}\n` +
            `是否继续？`
          );
          
          if (!userConfirmed) {
            throw new Error('用户取消了可能存在风险的操作');
          }
        }
      }
      
      // 设置防重入锁
      const callResult = this.startContractCall(contractAddress, functionName);
      
      if (!callResult.allowed) {
        throw new Error(callResult.reason);
      }
      
      try {
        // 执行实际的合约调用
        const result = await this.executeContractCall(signer, contractAddress, functionName, params, options);
        
        return result;
      } finally {
        // 确保释放防重入锁
        this.endContractCall(callResult.callId);
      }
    } catch (error) {
      console.error('安全合约调用失败:', error);
      throw error;
    }
  },
  
  // 执行实际的合约调用
  async executeContractCall(signer, contractAddress, functionName, params = [], options = {}) {
    try {
      // 创建合约实例并执行调用
      // 此处应填入实际的合约调用逻辑
      // 例如使用ethers.js或web3.js
      console.log(`执行合约调用: ${contractAddress}.${functionName}`);
      
      // 模拟合约调用延迟
      await new Promise(resolve => setTimeout(resolve, 500));
      
      // 模拟返回结果
      return {
        success: true,
        transactionHash: '0x' + Math.random().toString(16).substr(2, 64),
        blockNumber: Math.floor(Math.random() * 10000000)
      };
    } catch (error) {
      console.error('合约调用执行失败:', error);
      throw error;
    }
  },
  
  // 检测可疑的调用模式
  detectSuspiciousCallPatterns() {
    const now = Date.now();
    const suspiciousPatterns = [];
    
    // 遍历所有合约调用状态
    for (const [key, state] of this.contractCallStates.entries()) {
      // 检查短时间内的频繁调用
      const timeSinceLastCall = now - state.lastCallTime;
      
      if (timeSinceLastCall < 100) { // 100毫秒内的调用被认为是可疑的
        suspiciousPatterns.push({
          callId: key,
          callCount: state.callCount,
          timeSinceLastCall: timeSinceLastCall,
          reason: '短时间内频繁调用，可能是重入攻击'
        });
      }
    }
    
    return suspiciousPatterns;
  },
  
  // 监控并重入攻击模式
  startReentrancyMonitoring() {
    // 定期检查可疑的调用模式
    setInterval(() => {
      const suspiciousPatterns = this.detectSuspiciousCallPatterns();
      
      if (suspiciousPatterns.length > 0) {
        console.warn('检测到潜在的重入攻击模式:', suspiciousPatterns);
        // 发送告警通知
        this.sendReentrancyAlert(suspiciousPatterns);
      }
    }, 5000); // 每5秒检查一次
  },
  
  // 发送重入攻击告警
  sendReentrancyAlert(patterns) {
    // 在实际应用中，这里可以向服务器发送告警或显示用户通知
    console.log('发送重入攻击告警:', patterns);
  }
};

// 使用示例：包装合约调用以添加防重入保护
async function protectedContractCall(signer, contractAddress, functionName, params = [], options = {}) {
  try {
    // 启动重入监控（如果尚未启动）
    if (!window.reentrancyMonitoringActive) {
      ReentrancyProtection.startReentrancyMonitoring();
      window.reentrancyMonitoringActive = true;
    }
    
    // 执行安全的合约调用
    const result = await ReentrancyProtection.safeContractCall(
      signer, contractAddress, functionName, params, options
    );
    
    console.log('合约调用成功:', result);
    return result;
  } catch (error) {
    console.error('合约调用失败:', error);
    throw error;
  }
}