Web3前端安全审计工具

在Web3应用开发中，安全审计是确保应用健壮性和用户资产安全的关键环节。本文将深入介绍Web3前端安全审计的核心工具、实现方法和最佳实践，帮助开发团队构建更加安全的去中心化应用。

1. Web3前端安全审计概述

1.1 安全审计的重要性

Web3前端应用直接与用户的钱包和资产交互，其安全性至关重要。安全审计可以帮助开发团队：

• 发现潜在的安全漏洞和逻辑缺陷
• 确保代码符合安全最佳实践
• 防止用户资产被盗和数据泄露
• 提升用户对应用的信任度
• 符合监管和合规要求

1.2 安全审计的主要类型

Web3前端安全审计通常包括以下几种类型：

• 代码审查：人工检查源代码，寻找安全漏洞和潜在问题
• 自动化扫描：使用工具自动检测常见的安全问题和代码质量问题
• 渗透测试：模拟攻击行为，测试应用的防御能力
• 依赖审计：检查第三方库和依赖的安全性
• 合规性检查：确保应用符合相关安全标准和法规

1.3 安全审计的关键领域

在Web3前端应用中，需要特别关注的安全领域包括：

• 钱包集成和授权安全
• 智能合约交互安全
• 交易签名验证
• 密钥和敏感数据保护
• API安全和身份验证
• 跨链交互安全
• 防御常见的Web3攻击（如重入攻击、钓鱼攻击等）

2. 自动化安全审计工具

2.1 安全扫描工具实现

// Web3前端安全扫描工具
class Web3SecurityScanner {
  constructor(options = {}) {
    this.rootDir = options.rootDir || './src';
    this.excludePaths = options.excludePaths || ['/node_modules/', '/dist/', '/build/'];
    this.scanRules = options.scanRules || this.getDefaultScanRules();
    this.results = [];
    this.isScanning = false;
  }
  
  // 获取默认扫描规则
  getDefaultScanRules() {
    return [
      // Web3特定规则
      { name: 'InsecureWalletConnection', pattern: /walletconnect.*bridge=.*http:/gi, severity: 'high', description: '使用HTTP协议的WalletConnect桥接器' },
      { name: 'HardcodedPrivateKey', pattern: /privateKey|private_key|私钥|密钥.*=.*['"][0-9a-fA-F]{64}['"]/gi, severity: 'critical', description: '硬编码的私钥' },
      { name: 'UnsafeEval', pattern: /eval\(.*web3|ethereum.*\)|new Function\(.*web3|ethereum.*\)/gi, severity: 'high', description: '不安全的eval使用' },
      { name: 'UncheckedCallReturn', pattern: /contract\.[a-zA-Z0-9_]+\(.*\);\s*\/\/\s*no return check/gi, severity: 'medium', description: '未检查智能合约调用返回值' },
      { name: 'MissingChainIdValidation', pattern: /ethereum\.request\(.*method.*sendTransaction|sign/gi, severity: 'medium', description: '缺少链ID验证' },
      
      // 通用Web安全规则
      { name: 'XSSVulnerability', pattern: /innerHTML\s*=\s*.*userInput|document\.write\(.*userInput/gi, severity: 'high', description: '潜在的XSS漏洞' },
      { name: 'CSRFVulnerability', pattern: /fetch\(.*method:.*POST.*credentials:.*include/gi, severity: 'medium', description: '潜在的CSRF漏洞' },
      { name: 'InsecureCookie', pattern: /document\.cookie\s*=\s*[^;]*;\s*((?!HttpOnly)(?!Secure))/gi, severity: 'high', description: '不安全的Cookie设置' },
      { name: 'InsecureWebStorage', pattern: /localStorage\.setItem|sessionStorage\.setItem.*password|private|key|secret/gi, severity: 'medium', description: '在Web存储中存储敏感信息' }
    ];
  }
  
  // 开始安全扫描
  async startScan() {
    if (this.isScanning) {
      console.warn('安全扫描已经在进行中');
      return this.results;
    }
    
    this.isScanning = true;
    this.results = [];
    
    console.log(`开始Web3前端安全扫描，根目录: ${this.rootDir}`);
    
    try {
      // 扫描文件
      await this.scanFiles();
      
      // 生成扫描报告
      const report = this.generateReport();
      
      console.log(`安全扫描完成，发现 ${this.results.length} 个潜在问题`);
      
      return report;
    } catch (error) {
      console.error('安全扫描失败:', error);
      throw error;
    } finally {
      this.isScanning = false;
    }
  }
  
  // 扫描文件
  async scanFiles() {
    try {
      const fs = require('fs').promises;
      const path = require('path');
      
      // 递归扫描目录
      const scanDir = async (dir) => {
        const entries = await fs.readdir(dir, { withFileTypes: true });
        
        for (const entry of entries) {
          const fullPath = path.join(dir, entry.name);
          
          // 检查是否需要排除
          if (this.shouldExclude(fullPath)) {
            continue;
          }
          
          if (entry.isDirectory()) {
            await scanDir(fullPath);
          } else if (this.isScanableFile(fullPath)) {
            await this.scanFile(fullPath);
          }
        }
      };
      
      await scanDir(this.rootDir);
    } catch (error) {
      console.error('扫描文件时出错:', error);
      throw error;
    }
  }
  
  // 检查是否应该排除路径
  shouldExclude(filePath) {
    return this.excludePaths.some(excludePath => 
      filePath.includes(excludePath)
    );
  }
  
  // 检查文件是否可以扫描
  isScanableFile(filePath) {
    const scanableExtensions = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte'];
    const ext = filePath.substring(filePath.lastIndexOf('.'));
    return scanableExtensions.includes(ext);
  }
  
  // 扫描单个文件
  async scanFile(filePath) {
    try {
      const fs = require('fs').promises;
      const fileContent = await fs.readFile(filePath, 'utf8');
      
      // 应用每个扫描规则
      for (const rule of this.scanRules) {
        const matches = this.findMatches(fileContent, rule.pattern, filePath);
        
        if (matches.length > 0) {
          this.results.push({
            rule: rule.name,
            severity: rule.severity,
            description: rule.description,
            filePath,
            matches
          });
        }
      }
    } catch (error) {
      console.error(`扫描文件 ${filePath} 时出错:`, error);
    }
  }
  
  // 查找匹配项
  findMatches(fileContent, pattern, filePath) {
    const matches = [];
    let match;
    
    // 重置正则表达式的lastIndex
    pattern.lastIndex = 0;
    
    // 查找所有匹配项
    while ((match = pattern.exec(fileContent)) !== null) {
      // 计算行号
      const lines = fileContent.substring(0, match.index).split('\n');
      const lineNumber = lines.length;
      
      // 获取匹配行的上下文
      const lineContext = this.extractLineContext(fileContent, match.index);
      
      matches.push({
        lineNumber,
        matchedText: match[0],
        context: lineContext
      });
      
      // 防止无限循环（对于零宽度匹配）
      if (match.index === pattern.lastIndex) {
        pattern.lastIndex++;
      }
    }
    
    return matches;
  }
  
  // 提取行上下文
  extractLineContext(fileContent, index) {
    const lines = fileContent.split('\n');
    let lineNumber = 0;
    let currentIndex = 0;
    
    // 找到匹配的行
    for (let i = 0; i < lines.length; i++) {
      if (currentIndex + lines[i].length + 1 > index) {
        lineNumber = i;
        break;
      }
      currentIndex += lines[i].length + 1;
    }
    
    // 获取上下文（当前行和前后各一行）
    const startLine = Math.max(0, lineNumber - 1);
    const endLine = Math.min(lines.length - 1, lineNumber + 1);
    
    const context = [];
    for (let i = startLine; i <= endLine; i++) {
      context.push({
        line: i + 1, // 行号从1开始
        text: lines[i]
      });
    }
    
    return context;
  }
  
  // 生成扫描报告
  generateReport() {
    // 按严重性分组结果
    const resultsBySeverity = this.results.reduce((acc, result) => {
      if (!acc[result.severity]) {
        acc[result.severity] = [];
      }
      acc[result.severity].push(result);
      return acc;
    }, {});
    
    // 计算统计信息
    const stats = {
      totalIssues: this.results.length,
      bySeverity: {}
    };
    
    ['critical', 'high', 'medium', 'low'].forEach(severity => {
      stats.bySeverity[severity] = resultsBySeverity[severity] ? resultsBySeverity[severity].length : 0;
    });
    
    return {
      timestamp: new Date().toISOString(),
      scannedPaths: [this.rootDir],
      excludedPaths: this.excludePaths,
      stats,
      results: this.results,
      summary: this.generateSummary(stats)
    };
  }
  
  // 生成报告摘要
  generateSummary(stats) {
    if (stats.totalIssues === 0) {
      return '未发现安全问题';
    }
    
    if (stats.bySeverity.critical > 0) {
      return `发现 ${stats.bySeverity.critical} 个严重问题，需要立即修复`;
    }
    
    if (stats.bySeverity.high > 0) {
      return `发现 ${stats.bySeverity.high} 个高风险问题，建议优先修复`;
    }
    
    return `发现 ${stats.totalIssues} 个安全问题，包括 ${stats.bySeverity.medium} 个中等风险和 ${stats.bySeverity.low} 个低风险问题`;
  }
  
  // 导出报告
  async exportReport(format = 'json', outputPath = './security-scan-report') {
    try {
      const fs = require('fs').promises;
      const report = this.generateReport();
      
      let content = '';
      let extension = '';
      
      switch (format.toLowerCase()) {
        case 'json':
          content = JSON.stringify(report, null, 2);
          extension = '.json';
          break;
        case 'html':
          content = this.generateHtmlReport(report);
          extension = '.html';
          break;
        case 'markdown':
        case 'md':
          content = this.generateMarkdownReport(report);
          extension = '.md';
          break;
        default:
          throw new Error(`不支持的报告格式: ${format}`);
      }
      
      const fullOutputPath = outputPath + extension;
      await fs.writeFile(fullOutputPath, content, 'utf8');
      
      console.log(`报告已导出到: ${fullOutputPath}`);
      return fullOutputPath;
    } catch (error) {
      console.error('导出报告失败:', error);
      throw error;
    }
  }
  
  // 生成HTML报告
  generateHtmlReport(report) {
    // 简化的HTML报告生成逻辑
    // 实际实现可以更复杂，包含样式和交互功能
    return `
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Web3前端安全扫描报告</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 20px; }
    .summary { background-color: #f8f9fa; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
    .severity-critical { color: #dc3545; font-weight: bold; }
    .severity-high { color: #fd7e14; font-weight: bold; }
    .severity-medium { color: #ffc107; font-weight: bold; }
    .severity-low { color: #6c757d; }
    .issue { margin-bottom: 15px; padding: 15px; border: 1px solid #dee2e6; border-radius: 5px; }
    .issue-header { font-weight: bold; margin-bottom: 10px; }
    .code-block { background-color: #f8f9fa; padding: 10px; border-radius: 5px; font-family: monospace; white-space: pre-wrap; }
  </style>
</head>
<body>
  <h1>Web3前端安全扫描报告</h1>
  <div class="summary">
    <p>扫描时间: ${report.timestamp}</p>
    <p>扫描路径: ${report.scannedPaths.join(', ')}</p>
    <p>总问题数: ${report.stats.totalIssues}</p>
    <p>严重问题: ${report.stats.bySeverity.critical}</p>
    <p>高风险问题: ${report.stats.bySeverity.high}</p>
    <p>中等风险问题: ${report.stats.bySeverity.medium}</p>
    <p>低风险问题: ${report.stats.bySeverity.low}</p>
    <p>摘要: ${report.summary}</p>
  </div>
  
  <h2>详细问题列表</h2>
  ${report.results.map(issue => `
  <div class="issue">
    <div class="issue-header">
      <span class="severity-${issue.severity}">[${issue.severity.toUpperCase()}]</span> 
      ${issue.rule}: ${issue.description}
    </div>
    <p>文件路径: ${issue.filePath}</p>
    ${issue.matches.map(match => `
    <div class="match">
      <p>行号: ${match.lineNumber}</p>
      <div class="code-block">
        ${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
      </div>
      <p>匹配文本: ${match.matchedText}</p>
    </div>`).join('')}
  </div>`).join('')}
</body>
</html>`;
  }
  
(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

// 使用示例
const codeStyleChecker = new Web3CodeStyleChecker({
  rootDir: './src',
  excludePaths: ['/node_modules/', '/dist/', '/build/', '/test/'],
  // 可以自定义规则
});

// 运行代码风格与安全规范检查
async function runCodeStyleCheck() {
  try {
    console.log('开始Web3代码风格与安全规范检查...');
    const report = await codeStyleChecker.runCheck();
    
    console.log('代码检查完成，统计信息:');
    console.log(`  总问题数: ${report.stats.totalIssues}`);
    console.log(`  Web3相关问题: ${report.stats.byType.web3}`);
    console.log(`  代码风格问题: ${report.stats.byType.style}`);
    console.log(`  高风险问题: ${report.stats.bySeverity.high}`);
    
    // 导出报告
    await codeStyleChecker.exportReport('json', './code-style-report');
    await codeStyleChecker.exportReport('html', './code-style-report');
    await codeStyleChecker.exportReport('markdown', './code-style-report');
    
    return report;
  } catch (error) {
    console.error('代码检查失败:', error);
    throw error;
  }
}

// 与Git Hooks集成
function setupGitHooks() {
  console.log('设置Git Hooks以在提交前运行代码风格检查');
  // 实际实现需要创建或修改.git/hooks/pre-commit文件
  // 这里仅作示例
}
(report) {
    // 简化的Markdown报告生成逻辑
    return `# Web3前端安全扫描报告

## 报告摘要

- **扫描时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}: ${issue.description}

- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

// 使用示例
const securityScanner = new Web3SecurityScanner({
  rootDir: './src',
  excludePaths: ['/node_modules/', '/dist/', '/build/', '/test/'],
  scanRules: [
    // 可以添加自定义扫描规则
    ...new Web3SecurityScanner().getDefaultScanRules(),
    { name: 'CustomRule', pattern: /custom.*pattern/gi, severity: 'medium', description: '自定义扫描规则' }
  ]
});

// 运行安全扫描
async function runSecurityScan() {
  try {
    console.log('开始Web3前端安全扫描...');
    const report = await securityScanner.startScan();
    
    console.log('安全扫描完成，统计信息:');
    console.log(`  总问题数: ${report.stats.totalIssues}`);
    console.log(`  严重问题: ${report.stats.bySeverity.critical}`);
    console.log(`  高风险问题: ${report.stats.bySeverity.high}`);
    console.log(`  中等风险问题: ${report.stats.bySeverity.medium}`);
    console.log(`  低风险问题: ${report.stats.bySeverity.low}`);
    
    // 导出报告
    await securityScanner.exportReport('json', './security-report');
    await securityScanner.exportReport('html', './security-report');
    await securityScanner.exportReport('markdown', './security-report');
    
    return report;
  } catch (error) {
    console.error('安全扫描失败:', error);
    throw error;
  }
}

// 定期运行安全扫描
function setupPeriodicSecurityScan(intervalHours = 24) {
  console.log(`设置定期安全扫描，每 ${intervalHours} 小时执行一次`);
  
  // 立即执行一次
  runSecurityScan();
  
  // 设置定时器
  setInterval(() => {
    console.log('执行定期安全扫描...');
    runSecurityScan().catch(error => {
      console.error('定期安全扫描失败:', error);
    });
  }, intervalHours * 60 * 60 * 1000);
}

2. 智能合约交互安全检查工具

// Web3智能合约交互安全检查工具
class ContractInteractionSecurityChecker {
  constructor(web3Provider) {
    this.web3Provider = web3Provider;
    this.unsafeFunctions = this.getDefaultUnsafeFunctions();
    this.contractWhitelist = new Set();
    this.transactionHistory = [];
  }
  
  // 获取默认的不安全函数列表
  getDefaultUnsafeFunctions() {
    return [
      // 转账和资金相关的高风险函数
      'transfer', 'transferFrom', 'approve', 'increaseAllowance', 'decreaseAllowance',
      'transferOwnership', 'renounceOwnership', 'changeAdmin',
      'withdraw', 'withdrawAll', 'claimFunds', 'rescueFunds',
      
      // 状态修改函数
      'setParams', 'updateConfiguration', 'changeSettings',
      
      // 铸币和销毁函数
      'mint', 'burn', 'burnFrom',
      
      // 可能有风险的通用函数名
      'execute', 'call', 'delegatecall', 'send', 'fallback'
    ];
  }
  
  // 添加合约到白名单
  addContractToWhitelist(contractAddress) {
    this.contractWhitelist.add(contractAddress.toLowerCase());
    console.log(`合约 ${contractAddress} 已添加到白名单`);
  }
  
  // 从白名单移除合约
  removeContractFromWhitelist(contractAddress) {
    this.contractWhitelist.delete(contractAddress.toLowerCase());
    console.log(`合约 ${contractAddress} 已从白名单移除`);
  }
  
  // 检查合约是否在白名单中
  isContractWhitelisted(contractAddress) {
    return this.contractWhitelist.has(contractAddress.toLowerCase());
  }
  
  // 检查交易安全性
  async checkTransactionSafety(transaction) {
    try {
      const { to, data, value, from } = transaction;
      
      if (!to) {
        return {
          safe: false,
          reason: '目标地址不能为空',
          severity: 'high'
        };
      }
      
      // 检查是否向零地址发送资金
      if (to === '0x0000000000000000000000000000000000000000' && value && value > 0) {
        return {
          safe: false,
          reason: '禁止向零地址发送资金',
          severity: 'high'
        };
      }
      
      // 检查是否为智能合约
      const isContract = await this.isContractAddress(to);
      
      if (isContract) {
        // 检查是否与合约交互
        if (data) {
          // 解析函数签名
          const functionSignature = this.extractFunctionSignature(data);
          
          // 检查是否调用不安全函数
          const unsafeCheck = this.checkForUnsafeFunctions(functionSignature);
          if (!unsafeCheck.safe) {
            return unsafeCheck;
          }
          
          // 检查是否为白名单合约
          if (!this.isContractWhitelisted(to)) {
            return {
              safe: false,
              reason: `与非白名单合约 ${to} 交互可能存在风险`,
              severity: 'medium',
              contractAddress: to,
              functionSignature
            };
          }
        }
        
        // 检查是否向未知合约发送大额资金
        if (value && value > 0 && !this.isContractWhitelisted(to)) {
          return {
            safe: false,
            reason: `向未知合约 ${to} 发送大额资金存在风险`,
            severity: 'high',
            contractAddress: to,
            amount: value
          };
        }
      }
      
      // 检查是否重复发送相同的交易
      const duplicateCheck = this.checkForDuplicateTransaction(transaction);
      if (!duplicateCheck.safe) {
        return duplicateCheck;
      }
      
      // 所有检查通过
      return {
        safe: true,
        reason: '交易通过了安全检查',
        severity: 'low'
      };
    } catch (error) {
      console.error('检查交易安全性时出错:', error);
      return {
        safe: false,
        reason: `安全检查失败: ${error.message}`,
        severity: 'medium'
      };
    }
  }
  
  // 检查地址是否为合约地址
  async isContractAddress(address) {
    try {
      const code = await this.web3Provider.eth.getCode(address);
      // 合约地址的代码不为空
      return code !== '0x' && code !== '0x0';
    } catch (error) {
      console.error(`检查地址 ${address} 是否为合约时出错:`, error);
      // 出错时假设是合约以确保安全
      return true;
    }
  }
  
  // 提取函数签名
  extractFunctionSignature(data) {
    if (!data || data.length < 10) {
      return null;
    }
    
    // 函数签名是数据的前8个字符（不包括0x前缀）
    return data.substring(0, 10);
  }
  
  // 检查是否调用不安全函数
  checkForUnsafeFunctions(functionSignature) {
    if (!functionSignature) {
      return { safe: true };
    }
    
    // 这里可以实现更复杂的函数签名解析和匹配
    // 简化版：检查函数签名是否与已知不安全函数相关
    // 注意：实际应用中需要更精确的函数签名数据库
    
    // 这里仅作示例，真实场景需要维护函数签名和函数名的映射
    // const functionName = this.mapSignatureToFunctionName(functionSignature);
    
    // 简化处理：直接返回警告
    return {
      safe: false,
      reason: `调用智能合约函数 ${functionSignature} 可能存在风险，请确认合约的安全性`,
      severity: 'medium',
      functionSignature
    };
  }
  
  // 检查是否重复发送相同的交易
  checkForDuplicateTransaction(transaction) {
    const { to, data, value } = transaction;
    
    // 检查最近的交易是否有相同的to、data和value
    const recentTransactions = this.transactionHistory.slice(-10); // 只检查最近10笔交易
    
    for (const tx of recentTransactions) {
      if (tx.to === to && tx.data === data && tx.value === value) {
        return {
          safe: false,
          reason: '检测到可能的重复交易，请确认是否需要再次发送',
          severity: 'medium',
          previousTransaction: tx
        };
      }
    }
    
    return { safe: true };
  }
  
  // 记录交易
  recordTransaction(transaction, txHash, status) {
    const txRecord = {
      ...transaction,
      hash: txHash,
      status,
      timestamp: Date.now()
    };
    
    this.transactionHistory.push(txRecord);
    
    // 只保留最近100笔交易
    if (this.transactionHistory.length > 100) {
      this.transactionHistory.shift();
    }
    
    console.log(`交易记录已保存: ${txHash}，状态: ${status}`);
  }
  
  // 安全执行交易
  async executeTransactionSafely(transaction, options = {}) {
    const { requireConfirmation = true, confirmMessage } = options;
    
    try {
      // 检查交易安全性
      const safetyCheck = await this.checkTransactionSafety(transaction);
      
      if (!safetyCheck.safe) {
        console.warn('交易未通过安全检查:', safetyCheck);
        
        // 如果需要用户确认，显示警告
        if (requireConfirmation) {
          const userConfirmed = await this.showTransactionWarning(
            safetyCheck, 
            transaction,
            confirmMessage
          );
          
          if (!userConfirmed) {
            throw new Error('用户取消了不安全的交易');
          }
        } else {
          throw new Error(`交易未通过安全检查: ${safetyCheck.reason}`);
        }
      }
      
      // 执行交易
      const txHash = await this.web3Provider.eth.sendTransaction(transaction);
      
      // 记录交易
      this.recordTransaction(transaction, txHash, 'sent');
      
      console.log(`交易已发送: ${txHash}`);
      
      return txHash;
    } catch (error) {
      console.error('执行交易时出错:', error);
      
      // 记录失败的交易
      this.recordTransaction(transaction, null, 'failed');
      
      throw error;
    }
  }
  
  // 显示交易警告（实际实现需要UI支持）
  async showTransactionWarning(safetyCheck, transaction, customMessage) {
    // 注意：这是一个简化的实现
    // 实际应用中应该使用UI组件来显示警告
    
    console.warn('🚨 交易安全警告 🚨');
    console.warn(`原因: ${safetyCheck.reason}`);
    console.warn(`严重程度: ${safetyCheck.severity}`);
    console.warn(`目标地址: ${transaction.to}`);
    if (transaction.value) {
      console.warn(`金额: ${transaction.value} wei`);
    }
    if (transaction.data) {
      console.warn(`数据长度: ${transaction.data.length} 字节`);
    }
    
    // 模拟用户确认（实际应用中应该使用真实的用户交互）
    return new Promise(resolve => {
      // 这里应该是一个UI确认对话框
      // 简化示例：默认拒绝高风险交易，允许用户确认中等风险交易
      if (safetyCheck.severity === 'high') {
        console.warn('高风险交易已默认拒绝');
        resolve(false);
      } else {
        console.warn('请确认是否继续执行此交易');
        // 假设用户确认
        resolve(true);
      }
    });
  }
  
  // 获取交易历史
  getTransactionHistory() {
    return [...this.transactionHistory];
  }
  
  // 生成交易安全报告
  generateTransactionReport() {
    const totalTransactions = this.transactionHistory.length;
    const failedTransactions = this.transactionHistory.filter(tx => tx.status === 'failed').length;
    const highRiskTransactions = this.transactionHistory.filter(tx => 
      tx.safetyCheck && tx.safetyCheck.severity === 'high'
    ).length;
    
    return {
      timestamp: new Date().toISOString(),
      totalTransactions,
      failedTransactions,
      highRiskTransactions,
      transactionHistory: this.transactionHistory.map(tx => ({
        hash: tx.hash,
        to: tx.to,
        value: tx.value,
        status: tx.status,
        timestamp: tx.timestamp,
        safetyCheck: tx.safetyCheck || null
      }))
    };
  }
}

// 使用示例
function setupContractSecurityChecker(web3) {
  const securityChecker = new ContractInteractionSecurityChecker(web3);
  
  // 添加常用的可信合约到白名单
  securityChecker.addContractToWhitelist('0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D'); // Uniswap V2 Router
  securityChecker.addContractToWhitelist('0xdAC17F958D2ee523a2206206994597C13D831ec7'); // USDT
  securityChecker.addContractToWhitelist('0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'); // USDC
  
  return securityChecker;
}

// 安全发送交易示例
async function sendTransactionSecurely(securityChecker, transaction) {
  try {
    const txHash = await securityChecker.executeTransactionSafely(transaction, {
      requireConfirmation: true,
      confirmMessage: '请注意，此交易可能存在风险，请确认是否继续。'
    });
    
    console.log('交易已安全发送:', txHash);
    return txHash;
  } catch (error) {
    console.error('安全交易失败:', error);
    throw error;
  }
}

2.3 依赖包安全审计工具

// Web3项目依赖安全审计工具
class DependencySecurityAuditor {
  constructor(options = {}) {
    this.projectPath = options.projectPath || '.';
    this.packageManager = options.packageManager || 'npm'; // npm, yarn, pnpm
    this.vulnerabilityDatabase = options.vulnerabilityDatabase || 'npm'; // npm, snyk, etc.
    this.severityThreshold = options.severityThreshold || 'medium'; // low, medium, high, critical
  }
  
  // 运行依赖安全审计
  async auditDependencies() {
    try {
      console.log(`开始依赖安全审计，项目路径: ${this.projectPath}`);
      
      // 执行依赖审计命令
      const auditResult = await this.runAuditCommand();
      
      // 解析审计结果
      const parsedResult = this.parseAuditResult(auditResult);
      
      // 过滤结果
      const filteredResult = this.filterResultsBySeverity(parsedResult);
      
      // 生成报告
      const report = this.generateAuditReport(filteredResult);
      
      console.log(`依赖安全审计完成，发现 ${filteredResult.vulnerabilities.length} 个符合阈值的漏洞`);
      
      return report;
    } catch (error) {
      console.error('依赖安全审计失败:', error);
      throw error;
    }
  }
  
  // 执行审计命令
  async runAuditCommand() {
    try {
      const { exec } = require('child_process');
      const path = require('path');
      const cwd = path.resolve(this.projectPath);
      
      let command = '';
      
      switch (this.packageManager) {
        case 'npm':
          command = 'npm audit --json';
          break;
        case 'yarn':
          command = 'yarn audit --json';
          break;
        case 'pnpm':
          command = 'pnpm audit --json';
          break;
        default:
          throw new Error(`不支持的包管理器: ${this.packageManager}`);
      }
      
      return new Promise((resolve, reject) => {
        exec(command, { cwd }, (error, stdout, stderr) => {
          if (error) {
            // npm audit 在发现漏洞时会返回非零退出码，但我们仍然需要解析结果
            if (stdout) {
              try {
                const result = JSON.parse(stdout);
                resolve(result);
              } catch (parseError) {
                reject(new Error(`解析审计结果失败: ${parseError.message}`));
              }
            } else {
              reject(error);
            }
            return;
          }
          
          try {
            const result = JSON.parse(stdout);
            resolve(result);
          } catch (parseError) {
            reject(new Error(`解析审计结果失败: ${parseError.message}`));
          }
        });
      });
    } catch (error) {
      console.error('执行审计命令时出错:', error);
      throw error;
    }
  }
  
  // 解析审计结果
  parseAuditResult(rawResult) {
    try {
      const vulnerabilities = [];
      
      // 根据不同的包管理器和输出格式进行解析
      if (rawResult.vulnerabilities) {
        // npm 格式
        for (const [pkgName, vulns] of Object.entries(rawResult.vulnerabilities)) {
          vulns.forEach(vuln => {
            vulnerabilities.push({
              package: pkgName,
              version: vuln.version,
              severity: vuln.severity,
              title: vuln.title || vuln.name,
              description: vuln.description,
              cve: vuln.cves ? vuln.cves[0] : null,
              vulnerableVersions: vuln.vulnerable_versions,
              patchedVersions: vuln.patched_versions,
              recommendation: vuln.recommendation,
              url: vuln.url
            });
          });
        }
      } else if (rawResult.advisories) {
        // yarn 格式
        for (const [id, advisory] of Object.entries(rawResult.advisories)) {
          vulnerabilities.push({
            package: advisory.module_name,
            version: advisory.findings[0]?.version || 'unknown',
            severity: advisory.severity,
            title: advisory.title,
            description: advisory.description,
            cve: advisory.cves ? advisory.cves[0] : null,
            vulnerableVersions: advisory.vulnerable_versions,
            patchedVersions: advisory.patched_versions,
            recommendation: advisory.recommendation,
            url: advisory.url
          });
        }
      } else {
        // 其他格式或没有漏洞
        console.warn('未识别的审计结果格式或没有发现漏洞');
      }
      
      return {
        vulnerabilities,
        metadata: rawResult.metadata || {}
      };
    } catch (error) {
      console.error('解析审计结果时出错:', error);
      throw error;
    }
  }
  
  // 根据严重性过滤结果
  filterResultsBySeverity(parsedResult) {
    const severityLevels = { low: 1, medium: 2, high: 3, critical: 4 };
    const thresholdLevel = severityLevels[this.severityThreshold] || 2;
    
    const filteredVulnerabilities = parsedResult.vulnerabilities.filter(vuln => {
      const vulnLevel = severityLevels[vuln.severity] || 1;
      return vulnLevel >= thresholdLevel;
    });
    
    return {
      ...parsedResult,
      vulnerabilities: filteredVulnerabilities,
      filteredBySeverity: this.severityThreshold
    };
  }
  
  // 生成审计报告
  generateAuditReport(filteredResult) {
    const { vulnerabilities, metadata } = filteredResult;
    
    // 按严重性和包名分组
    const vulnsBySeverity = vulnerabilities.reduce((acc, vuln) => {
      if (!acc[vuln.severity]) {
        acc[vuln.severity] = [];
      }
      acc[vuln.severity].push(vuln);
      return acc;
    }, {});
    
    const vulnsByPackage = vulnerabilities.reduce((acc, vuln) => {
      if (!acc[vuln.package]) {
        acc[vuln.package] = [];
      }
      acc[vuln.package].push(vuln);
      return acc;
    }, {});
    
    // 计算统计信息
    const stats = {
      totalVulnerabilities: vulnerabilities.length,
      bySeverity: {},
      byPackage: Object.keys(vulnsByPackage).length
    };
    
    ['critical', 'high', 'medium', 'low'].forEach(severity => {
      stats.bySeverity[severity] = vulnsBySeverity[severity] ? vulnsBySeverity[severity].length : 0;
    });
    
    return {
      timestamp: new Date().toISOString(),
      projectPath: this.projectPath,
      packageManager: this.packageManager,
      vulnerabilityDatabase: this.vulnerabilityDatabase,
      severityThreshold: this.severityThreshold,
      stats,
      vulnerabilities,
      vulnsBySeverity,
      vulnsByPackage,
      metadata,
      summary: this.generateSummary(stats)
    };
  }
  
  // 生成报告摘要
  generateSummary(stats) {
    if (stats.totalVulnerabilities === 0) {
      return '未发现符合阈值的依赖漏洞';
    }
    
    let summary = `发现 ${stats.totalVulnerabilities} 个依赖漏洞，影响 ${stats.byPackage} 个包`;
    
    if (stats.bySeverity.critical > 0) {
      summary += `，其中 ${stats.bySeverity.critical} 个为严重漏洞`;
    }
    
    if (stats.bySeverity.high > 0) {
      summary += `，${stats.bySeverity.high} 个为高风险漏洞`;
    }
    
    return summary;
  }
  
  // 导出报告
  async exportReport(format = 'json', outputPath = './dependency-audit-report') {
    try {
      const fs = require('fs').promises;
      const path = require('path');
      const fullOutputPath = path.resolve(outputPath);
      
      // 确保目录存在
      const dir = path.dirname(fullOutputPath);
      try {
        await fs.mkdir(dir, { recursive: true });
      } catch (error) {
        // 目录已存在，忽略错误
      }
      
      // 生成报告
      const report = await this.auditDependencies();
      
      let content = '';
      let extension = '';
      
      switch (format.toLowerCase()) {
        case 'json':
          content = JSON.stringify(report, null, 2);
          extension = '.json';
          break;
        case 'html':
          content = this.generateHtmlReport(report);
          extension = '.html';
          break;
        case 'markdown':
        case 'md':
          content = this.generateMarkdownReport(report);
          extension = '.md';
          break;
        default:
          throw new Error(`不支持的报告格式: ${format}`);
      }
      
      const finalOutputPath = fullOutputPath + extension;
      await fs.writeFile(finalOutputPath, content, 'utf8');
      
      console.log(`依赖审计报告已导出到: ${finalOutputPath}`);
      return finalOutputPath;
    } catch (error) {
      console.error('导出依赖审计报告失败:', error);
      throw error;
    }
  }
  
  // 生成HTML报告
  generateHtmlReport(report) {
    // 简化的HTML报告生成逻辑
    return `
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Web3项目依赖安全审计报告</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 20px; }
    .summary { background-color: #f8f9fa; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
    .severity-critical { color: #dc3545; font-weight: bold; }
    .severity-high { color: #fd7e14; font-weight: bold; }
    .severity-medium { color: #ffc107; font-weight: bold; }
    .severity-low { color: #6c757d; }
    .vulnerability { margin-bottom: 15px; padding: 15px; border: 1px solid #dee2e6; border-radius: 5px; }
    .vulnerability-header { font-weight: bold; margin-bottom: 10px; }
    .vulnerability-details { margin-left: 20px; }
  </style>
</head>
<body>
  <h1>Web3项目依赖安全审计报告</h1>
  <div class="summary">
    <p>审计时间: ${report.timestamp}</p>
    <p>项目路径: ${report.projectPath}</p>
    <p>包管理器: ${report.packageManager}</p>
    <p>总漏洞数: ${report.stats.totalVulnerabilities}</p>
    <p>严重漏洞: ${report.stats.bySeverity.critical}</p>
    <p>高风险漏洞: ${report.stats.bySeverity.high}</p>
    <p>中等风险漏洞: ${report.stats.bySeverity.medium}</p>
    <p>低风险漏洞: ${report.stats.bySeverity.low}</p>
    <p>受影响的包数: ${report.stats.byPackage}</p>
    <p>摘要: ${report.summary}</p>
  </div>
  
  <h2>详细漏洞列表</h2>
  ${report.vulnerabilities.map((vuln, index) => `
  <div class="vulnerability">
    <div class="vulnerability-header">
      <span class="severity-${vuln.severity}">[${vuln.severity.toUpperCase()}]</span> 
      ${vuln.package}@${vuln.version}: ${vuln.title}
    </div>
    <div class="vulnerability-details">
      <p><strong>描述:</strong> ${vuln.description}</p>
      ${vuln.cve ? `<p><strong>CVE:</strong> <a href="https://cve.mitre.org/cgi-bin/cvename.cgi?name=${vuln.cve}" target="_blank">${vuln.cve}</a></p>` : ''}
      <p><strong>受影响版本:</strong> ${vuln.vulnerableVersions}</p>
      <p><strong>已修复版本:</strong> ${vuln.patchedVersions}</p>
      ${vuln.recommendation ? `<p><strong>修复建议:</strong> ${vuln.recommendation}</p>` : ''}
      ${vuln.url ? `<p><strong>更多信息:</strong> <a href="${vuln.url}" target="_blank">${vuln.url}</a></p>` : ''}
    </div>
  </div>`).join('')}
</body>
</html>`;
  }
  
  // 生成Markdown报告
  generateMarkdownReport(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

# 总结

Web3前端安全审计工具是一套全面的安全保障解决方案，专为Web3前端应用开发设计。本工具集包含四个核心组件：

1. **Web3SecurityScanner** - 提供基础的安全扫描功能，检测前端代码中的安全漏洞，如私钥泄露、不安全的钱包连接等

2. **ContractInteractionSecurityChecker** - 专注于智能合约交互的安全性，防止重入攻击、不安全的函数调用等问题

3. **DependencySecurityAuditor** - 对项目依赖进行安全审计，识别并报告第三方库中的已知漏洞

4. **Web3CodeStyleChecker** - 确保代码符合Web3安全最佳实践和代码风格规范

这些工具可以单独使用，也可以集成到开发工作流中，实现自动化的安全检查。通过定期运行安全审计，开发团队可以及早发现并修复安全隐患，提高Web3应用的安全性和可靠性。

Web3前端安全是一个持续的过程，需要开发者保持警惕，及时更新安全知识和工具。希望这套工具集能帮助开发者构建更加安全、可靠的Web3前端应用。(report) {
    // 完整的Markdown报告生成逻辑
    return `# Web3代码风格与安全规范检查报告

## 报告摘要

- **检查时间**: ${report.timestamp}
- **扫描路径**: ${report.scannedPaths.join(', ')}
- **总问题数**: ${report.stats.totalIssues}
- **Web3相关问题**: ${report.stats.byType.web3}
- **代码风格问题**: ${report.stats.byType.style}
- **严重问题**: ${report.stats.bySeverity.critical}
- **高风险问题**: ${report.stats.bySeverity.high}
- **中等风险问题**: ${report.stats.bySeverity.medium}
- **低风险问题**: ${report.stats.bySeverity.low}
- **摘要**: ${report.summary}

## 详细问题列表

${report.results.map((issue, index) => `
### ${index + 1}. [${issue.severity.toUpperCase()}] ${issue.rule}

- **描述**: ${issue.description}
- **文件路径**: ${issue.filePath}
${issue.matches.map(match => `
#### 匹配项（行 ${match.lineNumber}）

\`\`\`javascript
${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
\`\`\`

- **匹配文本**: \`${match.matchedText}\``).join('')}`).join('')}`;
  }
}

## 报告摘要

- **审计时间**: ${report.timestamp}
- **项目路径**: ${report.projectPath}
- **包管理器**: ${report.packageManager}
- **总漏洞数**: ${report.stats.totalVulnerabilities}
- **严重漏洞**: ${report.stats.bySeverity.critical}
- **高风险漏洞**: ${report.stats.bySeverity.high}
- **中等风险漏洞**: ${report.stats.bySeverity.medium}
- **低风险漏洞**: ${report.stats.bySeverity.low}
- **受影响的包数**: ${report.stats.byPackage}
- **摘要**: ${report.summary}

## 详细漏洞列表

${report.vulnerabilities.map((vuln, index) => `
### ${index + 1}. [${vuln.severity.toUpperCase()}] ${vuln.package}@${vuln.version}

- **标题**: ${vuln.title}
- **描述**: ${vuln.description}
${vuln.cve ? `- **CVE**: [${vuln.cve}](https://cve.mitre.org/cgi-bin/cvename.cgi?name=${vuln.cve})` : ''}
- **受影响版本**: ${vuln.vulnerableVersions}
- **已修复版本**: ${vuln.patchedVersions}
${vuln.recommendation ? `- **修复建议**: ${vuln.recommendation}` : ''}
${vuln.url ? `- **更多信息**: [${vuln.url}](${vuln.url})` : ''}`).join('')}`;
  }
  
  // 获取修复建议
  getFixRecommendations() {
    // 基于审计结果生成修复建议
    // 实际实现需要先运行审计
    return {
      upgradePackages: [], // 需要升级的包
      replacePackages: [], // 需要替换的包
      removePackages: [],  // 需要移除的包
      securityPatches: []  // 安全补丁
    };
  }
}

// 使用示例
const dependencyAuditor = new DependencySecurityAuditor({
  projectPath: '.',
  packageManager: 'npm',
  severityThreshold: 'medium'
});

// 运行依赖安全审计
async function runDependencyAudit() {
  try {
    console.log('开始依赖安全审计...');
    const report = await dependencyAuditor.auditDependencies();
    
    console.log('依赖安全审计完成，统计信息:');
    console.log(`  总漏洞数: ${report.stats.totalVulnerabilities}`);
    console.log(`  严重漏洞: ${report.stats.bySeverity.critical}`);
    console.log(`  高风险漏洞: ${report.stats.bySeverity.high}`);
    console.log(`  中等风险漏洞: ${report.stats.bySeverity.medium}`);
    console.log(`  受影响的包数: ${report.stats.byPackage}`);
    
    // 导出报告
    await dependencyAuditor.exportReport('json', './dependency-report');
    await dependencyAuditor.exportReport('html', './dependency-report');
    await dependencyAuditor.exportReport('markdown', './dependency-report');
    
    return report;
  } catch (error) {
    console.error('依赖安全审计失败:', error);
    throw error;
  }
}

// 定期运行依赖安全审计
function setupPeriodicDependencyAudit(intervalHours = 7 * 24) { // 每周运行一次
  console.log(`设置定期依赖安全审计，每 ${intervalHours} 小时执行一次`);
  
  // 立即执行一次
  runDependencyAudit();
  
  // 设置定时器
  setInterval(() => {
    console.log('执行定期依赖安全审计...');
    runDependencyAudit().catch(error => {
      console.error('定期依赖安全审计失败:', error);
    });
  }, intervalHours * 60 * 60 * 1000);
}

3. 代码审查工具

3.1 Web3代码风格与安全规范检查器

// Web3代码风格与安全规范检查器
class Web3CodeStyleChecker {
  constructor(options = {}) {
    this.rootDir = options.rootDir || './src';
    this.excludePaths = options.excludePaths || ['/node_modules/', '/dist/', '/build/'];
    this.web3Rules = this.getDefaultWeb3Rules();
    this.styleRules = this.getDefaultStyleRules();
    this.results = [];
  }
  
  // 获取默认的Web3特定规则
  getDefaultWeb3Rules() {
    return [
      // Web3安全规则
      { name: 'NoConsoleLoggingOfPrivateKeys', pattern: /console\.log.*privateKey|私钥/gi, severity: 'high', description: '禁止在控制台输出私钥或敏感信息' },
      { name: 'NoHardcodedContractAddresses', pattern: /0x[0-9a-fA-F]{40}\s*[,;]/g, severity: 'medium', description: '避免硬编码合约地址' },
      { name: 'UseSafeMath', pattern: /\+|-|\*|\/\s*\/\/\s*no safe math/gi, severity: 'medium', description: '对于整数运算应使用安全数学库' },
      { name: 'ValidateChainId', pattern: /ethereum\.request.*method:.*sendTransaction.*!.*chainId/gi, severity: 'high', description: '交易请求应验证链ID' },
      { name: 'UseApprovalAmountLimits', pattern: /approve\(.*maxUint256|\d{18,}/gi, severity: 'high', description: '避免无限授权或过大金额授权' },
      
      // Web3最佳实践
      { name: 'PreferEthersOverWeb3', pattern: /require\(.*web3\.js/gi, severity: 'low', description: '优先使用ethers.js而非web3.js' },
      { name: 'EventListeningCleanup', pattern: /on\(.*accountsChanged|chainChanged.*\/\/\s*no cleanup/gi, severity: 'medium', description: '事件监听器应正确清理' },
      { name: 'UseEstimateGas', pattern: /gasLimit\s*=\s*\d+.*\/\/\s*hardcoded/gi, severity: 'medium', description: '避免硬编码gasLimit，应使用estimateGas' },
      { name: 'CheckTransactionReceipt', pattern: /sendTransaction.*\/\/\s*no receipt check/gi, severity: 'medium', description: '发送交易后应检查交易收据' }
    ];
  }
  
  // 获取默认的代码风格规则
  getDefaultStyleRules() {
    return [
      // 代码风格规则
      { name: 'NoVarKeyword', pattern: /\bvar\b/gi, severity: 'low', description: '避免使用var关键字，应使用let或const' },
      { name: 'ArrowFunctionStyle', pattern: /function\s*\([^)]*\)\s*=>/gi, severity: 'low', description: '箭头函数语法不规范' },
      { name: 'SemicolonMissing', pattern: /[^;]\n\s*[^\s{}]/gm, severity: 'low', description: '可能缺少分号' },
      { name: 'MaxLineLength', pattern: /.{120,}/gm, severity: 'low', description: '代码行过长（超过120个字符）' },
      { name: 'ConsistentQuotes', pattern: /['"].*['"]\s*\/\/\s*inconsistent quotes/gi, severity: 'low', description: '引号使用不一致' }
    ];
  }
  
  // 运行代码风格与安全规范检查
  async runCheck() {
    try {
      console.log(`开始Web3代码风格与安全规范检查，根目录: ${this.rootDir}`);
      
      this.results = [];
      
      // 扫描文件
      await this.scanFiles();
      
      // 生成报告
      const report = this.generateReport();
      
      console.log(`代码检查完成，发现 ${this.results.length} 个问题`);
      
      return report;
    } catch (error) {
      console.error('代码检查失败:', error);
      throw error;
    }
  }
  
  // 扫描文件
  async scanFiles() {
    try {
      const fs = require('fs').promises;
      const path = require('path');
      
      // 递归扫描目录
      const scanDir = async (dir) => {
        const entries = await fs.readdir(dir, { withFileTypes: true });
        
        for (const entry of entries) {
          const fullPath = path.join(dir, entry.name);
          
          // 检查是否需要排除
          if (this.shouldExclude(fullPath)) {
            continue;
          }
          
          if (entry.isDirectory()) {
            await scanDir(fullPath);
          } else if (this.isScanableFile(fullPath)) {
            await this.scanFile(fullPath);
          }
        }
      };
      
      await scanDir(this.rootDir);
    } catch (error) {
      console.error('扫描文件时出错:', error);
      throw error;
    }
  }
  
  // 检查是否应该排除路径
  shouldExclude(filePath) {
    return this.excludePaths.some(excludePath => 
      filePath.includes(excludePath)
    );
  }
  
  // 检查文件是否可以扫描
  isScanableFile(filePath) {
    const scanableExtensions = ['.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte'];
    const ext = filePath.substring(filePath.lastIndexOf('.'));
    return scanableExtensions.includes(ext);
  }
  
  // 扫描单个文件
  async scanFile(filePath) {
    try {
      const fs = require('fs').promises;
      const fileContent = await fs.readFile(filePath, 'utf8');
      
      // 应用所有规则（Web3规则和风格规则）
      const allRules = [...this.web3Rules, ...this.styleRules];
      
      for (const rule of allRules) {
        const matches = this.findMatches(fileContent, rule.pattern, filePath);
        
        if (matches.length > 0) {
          this.results.push({
            rule: rule.name,
            severity: rule.severity,
            description: rule.description,
            filePath,
            matches
          });
        }
      }
    } catch (error) {
      console.error(`扫描文件 ${filePath} 时出错:`, error);
    }
  }
  
  // 查找匹配项
  findMatches(fileContent, pattern, filePath) {
    const matches = [];
    let match;
    
    // 重置正则表达式的lastIndex
    pattern.lastIndex = 0;
    
    // 查找所有匹配项
    while ((match = pattern.exec(fileContent)) !== null) {
      // 计算行号
      const lines = fileContent.substring(0, match.index).split('\n');
      const lineNumber = lines.length;
      
      // 获取匹配行的上下文
      const lineContext = this.extractLineContext(fileContent, match.index);
      
      matches.push({
        lineNumber,
        matchedText: match[0],
        context: lineContext
      });
      
      // 防止无限循环（对于零宽度匹配）
      if (match.index === pattern.lastIndex) {
        pattern.lastIndex++;
      }
    }
    
    return matches;
  }
  
  // 提取行上下文
  extractLineContext(fileContent, index) {
    const lines = fileContent.split('\n');
    let lineNumber = 0;
    let currentIndex = 0;
    
    // 找到匹配的行
    for (let i = 0; i < lines.length; i++) {
      if (currentIndex + lines[i].length + 1 > index) {
        lineNumber = i;
        break;
      }
      currentIndex += lines[i].length + 1;
    }
    
    // 获取上下文（当前行和前后各一行）
    const startLine = Math.max(0, lineNumber - 1);
    const endLine = Math.min(lines.length - 1, lineNumber + 1);
    
    const context = [];
    for (let i = startLine; i <= endLine; i++) {
      context.push({
        line: i + 1, // 行号从1开始
        text: lines[i]
      });
    }
    
    return context;
  }
  
  // 生成报告
  generateReport() {
    // 按规则类型分组结果
    const resultsByType = {
      web3: this.results.filter(result => 
        this.web3Rules.some(rule => rule.name === result.rule)
      ),
      style: this.results.filter(result => 
        this.styleRules.some(rule => rule.name === result.rule)
      )
    };
    
    // 按严重性分组结果
    const resultsBySeverity = this.results.reduce((acc, result) => {
      if (!acc[result.severity]) {
        acc[result.severity] = [];
      }
      acc[result.severity].push(result);
      return acc;
    }, {});
    
    // 计算统计信息
    const stats = {
      totalIssues: this.results.length,
      byType: {
        web3: resultsByType.web3.length,
        style: resultsByType.style.length
      },
      bySeverity: {}
    };
    
    ['critical', 'high', 'medium', 'low'].forEach(severity => {
      stats.bySeverity[severity] = resultsBySeverity[severity] ? resultsBySeverity[severity].length : 0;
    });
    
    return {
      timestamp: new Date().toISOString(),
      scannedPaths: [this.rootDir],
      excludedPaths: this.excludePaths,
      stats,
      results: this.results,
      resultsByType,
      resultsBySeverity,
      summary: this.generateSummary(stats)
    };
  }
  
  // 生成报告摘要
  generateSummary(stats) {
    if (stats.totalIssues === 0) {
      return '代码符合所有检查规则';
    }
    
    let summary = `发现 ${stats.totalIssues} 个代码问题`;
    
    if (stats.byType.web3 > 0) {
      summary += `，其中 ${stats.byType.web3} 个与Web3安全和最佳实践相关`;
    }
    
    if (stats.byType.style > 0) {
      summary += `，${stats.byType.style} 个与代码风格相关`;
    }
    
    if (stats.bySeverity.high > 0) {
      summary += `。发现 ${stats.bySeverity.high} 个高风险问题，需要优先修复`;
    }
    
    return summary;
  }
  
  // 导出报告
  async exportReport(format = 'json', outputPath = './code-style-report') {
    try {
      const fs = require('fs').promises;
      const report = this.generateReport();
      
      let content = '';
      let extension = '';
      
      switch (format.toLowerCase()) {
        case 'json':
          content = JSON.stringify(report, null, 2);
          extension = '.json';
          break;
        case 'html':
          content = this.generateHtmlReport(report);
          extension = '.html';
          break;
        case 'markdown':
        case 'md':
          content = this.generateMarkdownReport(report);
          extension = '.md';
          break;
        default:
          throw new Error(`不支持的报告格式: ${format}`);
      }
      
      const fullOutputPath = outputPath + extension;
      await fs.writeFile(fullOutputPath, content, 'utf8');
      
      console.log(`代码检查报告已导出到: ${fullOutputPath}`);
      return fullOutputPath;
    } catch (error) {
      console.error('导出报告失败:', error);
      throw error;
    }
  }
  
  // 生成HTML报告
  generateHtmlReport(report) {
    // 简化的HTML报告生成逻辑
    return `
<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Web3代码风格与安全规范检查报告</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 20px; }
    .summary { background-color: #f8f9fa; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
    .severity-critical { color: #dc3545; font-weight: bold; }
    .severity-high { color: #fd7e14; font-weight: bold; }
    .severity-medium { color: #ffc107; font-weight: bold; }
    .severity-low { color: #6c757d; }
    .issue { margin-bottom: 15px; padding: 15px; border: 1px solid #dee2e6; border-radius: 5px; }
    .issue-header { font-weight: bold; margin-bottom: 10px; }
    .code-block { background-color: #f8f9fa; padding: 10px; border-radius: 5px; font-family: monospace; white-space: pre-wrap; }
  </style>
</head>
<body>
  <h1>Web3代码风格与安全规范检查报告</h1>
  <div class="summary">
    <p>检查时间: ${report.timestamp}</p>
    <p>扫描路径: ${report.scannedPaths.join(', ')}</p>
    <p>总问题数: ${report.stats.totalIssues}</p>
    <p>Web3相关问题: ${report.stats.byType.web3}</p>
    <p>代码风格问题: ${report.stats.byType.style}</p>
    <p>严重问题: ${report.stats.bySeverity.critical}</p>
    <p>高风险问题: ${report.stats.bySeverity.high}</p>
    <p>中等风险问题: ${report.stats.bySeverity.medium}</p>
    <p>低风险问题: ${report.stats.bySeverity.low}</p>
    <p>摘要: ${report.summary}</p>
  </div>
  
  <h2>详细问题列表</h2>
  ${report.results.map((issue, index) => `
  <div class="issue">
    <div class="issue-header">
      <span class="severity-${issue.severity}">[${issue.severity.toUpperCase()}]</span> 
      ${issue.rule}: ${issue.description}
    </div>
    <p>文件路径: ${issue.filePath}</p>
    ${issue.matches.map(match => `
    <div class="match">
      <p>行号: ${match.lineNumber}</p>
      <div class="code-block">
        ${match.context.map(line => `${line.line}: ${line.text}`).join('\n')}
      </div>
      <p>匹配文本: ${match.matchedText}</p>
    </div>`).join('')}
  </div>`).join('')}
</body>
</html>`;
  }
  
  // 生成Markdown报告
  generateMarkdownReport