011_NFT安全：数字艺术与收藏品的全方位保护策略

NFT安全生态系统：
1. 协议层：NFT标准、智能合约安全
2. 交易层：市场平台、交易验证、支付安全
3. 资产层：元数据存储、内容完整性、版权保护
4. 钱包层：私钥管理、签名验证、授权控制
5. 用户层：安全意识、钓鱼防范、资产保护

// 安全的ERC-721实现示例
// 基于OpenZeppelin的安全实现，添加额外的安全检查
contract SecureNFT is ERC721, Ownable, ReentrancyGuard {
    using Strings for uint256;
    
    // 元数据相关
    string private _baseTokenURI;
    bool private _isBaseURIInitialized = false;
    
    // 铸造控制
    uint256 public totalSupply;
    uint256 public maxSupply = 10000;
    bool public isMintingEnabled = false;
    uint256 public mintPrice = 0.05 ether;
    uint256 public maxPerWallet = 5;
    
    // 暂停控制
    bool public isPaused = false;
    
    // 黑名单（防止恶意地址）
    mapping(address => bool) public blacklist;
    
    // 事件定义
    event Minted(address indexed to, uint256 indexed tokenId);
    event MintingEnabled();
    event MintingDisabled();
    event BlacklistUpdated(address indexed user, bool isBlacklisted);
    event BaseURIUpdated(string newBaseURI);
    
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {
        // 初始化合约
    }
    
    // 修饰器：检查是否暂停
    modifier whenNotPaused() {
        require(!isPaused, "合约已暂停");
        _;
    }
    
    // 修饰器：检查是否在黑名单中
    modifier notBlacklisted() {
        require(!blacklist[msg.sender], "地址已被列入黑名单");
        _;
    }
    
    // 基础URI设置（仅初始化一次，增强安全性）
    function setBaseURI(string memory baseURI) external onlyOwner {
        require(!_isBaseURIInitialized, "基础URI已初始化，无法更改");
        _baseTokenURI = baseURI;
        _isBaseURIInitialized = true;
        emit BaseURIUpdated(baseURI);
    }
    
    // 获取基础URI
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }
    
    // 启用铸造
    function enableMinting() external onlyOwner {
        isMintingEnabled = true;
        emit MintingEnabled();
    }
    
    // 禁用铸造
    function disableMinting() external onlyOwner {
        isMintingEnabled = false;
        emit MintingDisabled();
    }
    
    // 单个铸造函数
    function mint() external payable nonReentrant whenNotPaused notBlacklisted {
        require(isMintingEnabled, "铸造功能未启用");
        require(totalSupply < maxSupply, "已达到最大供应量");
        require(msg.value >= mintPrice, "资金不足");
        require(balanceOf(msg.sender) < maxPerWallet, "超过每个钱包的最大数量限制");
        
        uint256 tokenId = totalSupply + 1;
        totalSupply = tokenId;
        
        _safeMint(msg.sender, tokenId);
        emit Minted(msg.sender, tokenId);
    }
    
    // 批量铸造函数（更安全的实现）
    function mintBatch(uint256 quantity) external payable nonReentrant whenNotPaused notBlacklisted {
        require(isMintingEnabled, "铸造功能未启用");
        require(quantity > 0, "数量必须大于0");
        require(totalSupply + quantity <= maxSupply, "超过最大供应量");
        require(msg.value >= mintPrice * quantity, "资金不足");
        require(balanceOf(msg.sender) + quantity <= maxPerWallet, "超过每个钱包的最大数量限制");
        
        for (uint256 i = 0; i < quantity; i++) {
            uint256 tokenId = totalSupply + 1;
            totalSupply = tokenId;
            _safeMint(msg.sender, tokenId);
            emit Minted(msg.sender, tokenId);
        }
    }
    
    // 管理员铸造（白名单或特殊铸造）
    function adminMint(address to, uint256 quantity) external onlyOwner {
        require(to != address(0), "无效的接收地址");
        require(quantity > 0, "数量必须大于0");
        require(totalSupply + quantity <= maxSupply, "超过最大供应量");
        
        for (uint256 i = 0; i < quantity; i++) {
            uint256 tokenId = totalSupply + 1;
            totalSupply = tokenId;
            _safeMint(to, tokenId);
            emit Minted(to, tokenId);
        }
    }
    
    // 暂停合约
    function pause() external onlyOwner {
        isPaused = true;
    }
    
    // 恢复合约
    function unpause() external onlyOwner {
        isPaused = false;
    }
    
    // 更新黑名单
    function updateBlacklist(address user, bool isBlacklisted) external onlyOwner {
        require(user != address(0), "无效的用户地址");
        blacklist[user] = isBlacklisted;
        emit BlacklistUpdated(user, isBlacklisted);
    }
    
    // 紧急提款函数（仅在紧急情况下使用）
    function emergencyWithdraw() external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "余额为零");
        
        (bool success, ) = owner().call{value: balance}("");
        require(success, "提款失败");
    }
    
    // 检查tokenId是否有效
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);
        // 添加额外的安全检查
        require(to != address(0), "接收地址不能为零地址");
        require(!blacklist[to], "接收地址在黑名单中");
    }
    
    // 重写tokenURI函数，增强安全性
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI查询不存在的token");
        
        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }
    
    // 防止合约接收以太币（除了铸造外）
    receive() external payable {
        revert("请使用mint或mintBatch函数进行铸造");
    }
}

// 安全的元数据管理实现
contract SecureMetadataNFT is ERC721, Ownable {
    // 元数据存储
    mapping(uint256 => string) private _tokenURIs;
    mapping(uint256 => bool) private _metadataFrozen;
    bool public isMetadataLocked = false;
    
    // 事件定义
    event MetadataFrozen(uint256 indexed tokenId);
    event TokenURIUpdated(uint256 indexed tokenId, string uri);
    event MetadataGloballyLocked();
    
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
    
    // 设置tokenURI
    function setTokenURI(uint256 tokenId, string memory _tokenURI) external onlyOwner {
        require(_exists(tokenId), "ERC721Metadata: URI设置到不存在的token");
        require(!_metadataFrozen[tokenId], "元数据已冻结，无法修改");
        require(!isMetadataLocked, "所有元数据已全局锁定");
        
        _tokenURIs[tokenId] = _tokenURI;
        emit TokenURIUpdated(tokenId, _tokenURI);
    }
    
    // 冻结单个NFT的元数据
    function freezeMetadata(uint256 tokenId) external onlyOwner {
        require(_exists(tokenId), "Token不存在");
        require(!_metadataFrozen[tokenId], "元数据已冻结");
        
        _metadataFrozen[tokenId] = true;
        emit MetadataFrozen(tokenId);
    }
    
    // 全局锁定所有元数据
    function globallyLockMetadata() external onlyOwner {
        require(!isMetadataLocked, "元数据已全局锁定");
        isMetadataLocked = true;
        emit MetadataGloballyLocked();
    }
    
    // 重写tokenURI函数
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI查询不存在的token");
        
        string memory _tokenURI = _tokenURIs[tokenId];
        require(bytes(_tokenURI).length > 0, "TokenURI未设置");
        
        return _tokenURI;
    }
    
    // 检查元数据是否冻结
    function isMetadataFrozen(uint256 tokenId) public view returns (bool) {
        return _metadataFrozen[tokenId];
    }
}

// NFT交易安全验证脚本
class NFTSecurityValidator {
  constructor(provider, userWallet) {
    this.provider = provider;
    this.wallet = userWallet;
    this.knownScamContracts = new Set([
      '0x123abc...', // 已知的欺诈合约地址
      // 更多已知欺诈合约
    ]);
    this.verifiedMarketplaces = {
      '0xabc123...': 'OpenSea',
      '0xdef456...': 'Rarible',
      // 更多已验证市场
    };
  }
  
  // 验证NFT合约
  async verifyNFTContract(contractAddress) {
    // 1. 检查是否为已知欺诈合约
    if (this.knownScamContracts.has(contractAddress)) {
      return {
        isSafe: false,
        reason: '已知的欺诈合约',
        confidence: 100
      };
    }
    
    // 2. 检查合约是否已验证
    const isVerified = await this.checkContractVerification(contractAddress);
    
    // 3. 分析合约代码（如果已验证）
    let codeAnalysis = {};
    if (isVerified) {
      codeAnalysis = await this.analyzeContractCode(contractAddress);
    }
    
    return {
      isSafe: isVerified && !codeAnalysis.hasVulnerabilities,
      isVerified,
      codeAnalysis,
      confidence: isVerified ? (codeAnalysis.hasVulnerabilities ? 30 : 85) : 10
    };
  }
  
  // 验证交易
  async verifyTransaction(txData) {
    const warnings = [];
    
    // 1. 验证合约地址
    const contractVerification = await this.verifyNFTContract(txData.to);
    if (!contractVerification.isSafe) {
      warnings.push(`警告: 目标合约存在风险 - ${contractVerification.reason}`);
    }
    
    // 2. 检查gas价格是否合理
    const currentGasPrice = await this.provider.getGasPrice();
    const userGasPrice = txData.gasPrice || currentGasPrice;
    const gasPriceRatio = userGasPrice.div(currentGasPrice).toNumber();
    
    if (gasPriceRatio > 3) {
      warnings.push(`警告: Gas价格比当前市场高${Math.round((gasPriceRatio - 1) * 100)}%`);
    }
    
    // 3. 检查是否为授权交易
    if (this.isApprovalTransaction(txData.data)) {
      const approvalAmount = this.extractApprovalAmount(txData.data);
      if (approvalAmount.isMaxUint256()) {
        warnings.push('警告: 检测到无限授权，请考虑使用精确授权');
      }
    }
    
    // 4. 检查交易是否为已知市场
    if (this.verifiedMarketplaces[txData.to]) {
      const marketplaceName = this.verifiedMarketplaces[txData.to];
      console.log(`交易目标: 已验证市场 ${marketplaceName}`);
    } else {
      warnings.push('警告: 交易目标不是已知的已验证NFT市场');
    }
    
    return {
      warnings,
      isHighRisk: warnings.length >= 2,
      recommendedActions: warnings.length > 0 ? ['请仔细检查交易详情', '考虑暂停交易'] : []
    };
  }
  
  // 检查是否为授权交易
  isApprovalTransaction(data) {
    // 检查是否为ERC-721或ERC-1155的授权函数签名
    const approvalFunctionSignatures = [
      '0x095ea7b3', // approve(address,uint256)
      '0xa22cb465', // setApprovalForAll(address,bool)
      '0x2eb2c2d6', // isApprovedForAll(address,address)
      '0xd8b5a4dc', // safeTransferFrom(address,address,uint256)
      '0xf242432a', // safeTransferFrom(address,address,uint256,bytes)
      '0x23b872dd', // transferFrom(address,address,uint256)
    ];
    
    if (!data || data.length < 10) return false;
    
    const functionSignature = data.slice(0, 10); // 前10个字符是函数签名
    return approvalFunctionSignatures.includes(functionSignature);
  }
  
  // 提取授权金额
  extractApprovalAmount(data) {
    // 实现提取授权金额的逻辑
    // 注意：这只是示例，实际实现需要根据不同的token标准调整
    return ethers.constants.MaxUint256; // 默认返回最大值
  }
  
  // 检查合约是否已验证
  async checkContractVerification(contractAddress) {
    try {
      // 在实际实现中，这里应该调用区块浏览器API
      // 例如：Etherscan, Polygonscan等
      // 这里仅作为示例返回模拟结果
      return Math.random() > 0.3; // 模拟70%的合约已验证
    } catch (error) {
      console.error('检查合约验证状态时出错:', error);
      return false;
    }
  }
  
  // 分析合约代码
  async analyzeContractCode(contractAddress) {
    // 实现合约代码分析逻辑
    // 实际实现中应该检查常见漏洞模式
    return {
      hasVulnerabilities: false,
      vulnerabilities: [],
      recommendations: []
    };
  }
  
  // 执行安全交易
  async executeSecureTransaction(txData) {
    // 1. 验证交易
    const verification = await this.verifyTransaction(txData);
    
    // 2. 如果存在高风险警告，要求二次确认
    if (verification.isHighRisk) {
      console.log('⚠️  检测到高风险交易:');
      verification.warnings.forEach(warning => console.log(`- ${warning}`));
      
      // 在实际应用中，这里应该显示用户界面让用户确认
      const userConfirmed = false; // 模拟用户拒绝
      if (!userConfirmed) {
        console.log('交易已取消，用户未确认高风险操作');
        return null;
      }
    }
    
    // 3. 执行交易
    try {
      const tx = await this.wallet.sendTransaction(txData);
      console.log(`交易已发送，哈希: ${tx.hash}`);
      
      // 4. 等待交易确认
      const receipt = await tx.wait();
      console.log(`交易已确认，区块: ${receipt.blockNumber}`);
      
      return receipt;
    } catch (error) {
      console.error('交易执行失败:', error);
      throw error;
    }
  }
  
  // 检查NFT地板价异常
  async checkFloorPriceAnomaly(contractAddress, listPrice) {
    try {
      // 获取当前地板价
      const currentFloorPrice = await this.getCurrentFloorPrice(contractAddress);
      
      // 计算偏差
      const deviation = Math.abs(listPrice - currentFloorPrice) / currentFloorPrice;
      
      if (deviation > 0.3) { // 30%偏差
        return {
          isAnomaly: true,
          currentFloorPrice,
          listedPrice: listPrice,
          deviationPercent: Math.round(deviation * 100),
          message: listPrice < currentFloorPrice 
            ? '价格显著低于当前地板价，可能是钓鱼或欺诈' 
            : '价格显著高于当前地板价，建议重新考虑'
        };
      }
      
      return { isAnomaly: false };
    } catch (error) {
      console.error('检查地板价异常时出错:', error);
      return { isAnomaly: false, error };
    }
  }
  
  // 获取当前地板价
  async getCurrentFloorPrice(contractAddress) {
    // 实现获取地板价的逻辑
    // 实际应用中应调用市场平台API
    return Math.random() * 10 + 0.1; // 模拟返回地板价
  }
}

// 使用示例
async function secureNFTTransaction() {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_KEY');
  const wallet = new ethers.Wallet('YOUR_PRIVATE_KEY', provider);
  
  const validator = new NFTSecurityValidator(provider, wallet);
  
  // 准备交易数据
  const txData = {
    to: '0xNFT_CONTRACT_ADDRESS',
    value: ethers.utils.parseEther('0.5'),
    gasLimit: 100000,
    data: '0x函数调用数据'
  };
  
  // 执行安全交易
  try {
    const receipt = await validator.executeSecureTransaction(txData);
    console.log('交易成功:', receipt);
  } catch (error) {
    console.error('交易失败:', error);
  }
}

// 使用IPFS存储NFT元数据的示例
const IPFS = require('ipfs-http-client');
const fs = require('fs');
const axios = require('axios');

class NFTMetadataStorage {
  constructor(ipfsConfig = { host: 'ipfs.infura.io', port: 5001, protocol: 'https' }) {
    this.ipfs = IPFS(ipfsConfig);
  }
  
  // 准备NFT元数据
  async prepareMetadata(name, description, imagePath, attributes = []) {
    try {
      // 1. 上传图片到IPFS
      const imageCID = await this.uploadFile(imagePath);
      const imageUrl = `ipfs://${imageCID}`;
      
      // 2. 创建元数据对象
      const metadata = {
        name,
        description,
        image: imageUrl,
        attributes,
        // 添加版本和时间戳等额外信息
        version: '1.0',
        created_at: new Date().toISOString(),
        // 可选：添加创建者签名以验证真实性
        creator_signature: null // 可通过签名验证创建者
      };
      
      // 3. 转换为JSON字符串
      const metadataJSON = JSON.stringify(metadata, null, 2);
      
      // 4. 上传元数据到IPFS
      const metadataCID = await this.uploadJSON(metadataJSON);
      
      return {
        metadata,
        imageCID,
        metadataCID,
        metadataURI: `ipfs://${metadataCID}`,
        imageUrl
      };
    } catch (error) {
      console.error('准备元数据时出错:', error);
      throw error;
    }
  }
  
  // 上传文件到IPFS
  async uploadFile(filePath) {
    try {
      const fileContent = fs.readFileSync(filePath);
      const added = await this.ipfs.add({
        path: filePath.split('/').pop(),
        content: fileContent
      });
      
      return added.cid.toString();
    } catch (error) {
      console.error('上传文件到IPFS时出错:', error);
      throw error;
    }
  }
  
  // 上传JSON字符串到IPFS
  async uploadJSON(jsonString) {
    try {
      const added = await this.ipfs.add({
        path: 'metadata.json',
        content: jsonString
      });
      
      return added.cid.toString();
    } catch (error) {
      console.error('上传JSON到IPFS时出错:', error);
      throw error;
    }
  }
  
  // 从IPFS获取元数据
  async getMetadataFromIPFS(cid) {
    try {
      const url = `https://ipfs.io/ipfs/${cid}`;
      const response = await axios.get(url);
      return response.data;
    } catch (error) {
      console.error(`从IPFS获取元数据(CID: ${cid})时出错:`, error);
      throw error;
    }
  }
  
  // 验证元数据完整性
  validateMetadata(metadata) {
    const requiredFields = ['name', 'description', 'image'];
    const missingFields = requiredFields.filter(field => !(field in metadata));
    
    if (missingFields.length > 0) {
      return {
        isValid: false,
        message: `缺少必要字段: ${missingFields.join(', ')}`
      };
    }
    
    // 验证image URL格式
    if (!metadata.image.startsWith('ipfs://') && 
        !metadata.image.startsWith('https://') && 
        !metadata.image.startsWith('http://')) {
      return {
        isValid: false,
        message: '无效的图片URL格式'
      };
    }
    
    return { isValid: true };
  }
  
  // 创建元数据备份
  async createMetadataBackup(cid, backupPath) {
    try {
      const metadata = await this.getMetadataFromIPFS(cid);
      
      // 创建备份目录（如果不存在）
      if (!fs.existsSync(backupPath)) {
        fs.mkdirSync(backupPath, { recursive: true });
      }
      
      // 保存元数据
      const backupFile = `${backupPath}/${cid}.json`;
      fs.writeFileSync(backupFile, JSON.stringify(metadata, null, 2));
      
      // 如果图片是IPFS链接，也备份图片
      if (metadata.image && metadata.image.startsWith('ipfs://')) {
        const imageCID = metadata.image.replace('ipfs://', '');
        await this.backupIPFSImage(imageCID, backupPath);
      }
      
      return backupFile;
    } catch (error) {
      console.error('创建元数据备份时出错:', error);
      throw error;
    }
  }
  
  // 备份IPFS图片
  async backupIPFSImage(imageCID, backupPath) {
    try {
      const imageUrl = `https://ipfs.io/ipfs/${imageCID}`;
      const response = await axios.get(imageUrl, { responseType: 'arraybuffer' });
      
      // 确定文件扩展名
      const contentType = response.headers['content-type'];
      let extension = 'jpg';
      if (contentType.includes('png')) extension = 'png';
      if (contentType.includes('gif')) extension = 'gif';
      
      const imageFile = `${backupPath}/${imageCID}.${extension}`;
      fs.writeFileSync(imageFile, response.data);
      
      return imageFile;
    } catch (error) {
      console.error(`备份IPFS图片(CID: ${imageCID})时出错:`, error);
      throw error;
    }
  }
  
  // 修复损坏的元数据引用
  async repairMetadataReference(contract, tokenId, newMetadataCID, privateKey) {
    try {
      // 在实际应用中，这里应该调用NFT合约的修复函数
      // 注意：合约需要实现修复元数据URI的函数，并有权限控制
      console.log(`修复Token ${tokenId} 的元数据引用为: ${newMetadataCID}`);
      
      // 示例实现（需要根据具体合约调整）
      /*
      const wallet = new ethers.Wallet(privateKey);
      const signer = wallet.connect(provider);
      const nftContract = new ethers.Contract(contractAddress, abi, signer);
      
      const tx = await nftContract.setTokenURI(tokenId, `ipfs://${newMetadataCID}`);
      await tx.wait();
      */
      
      return true;
    } catch (error) {
      console.error(`修复Token ${tokenId} 的元数据引用时出错:`, error);
      throw error;
    }
  }
  
  // 批量处理元数据
  async batchProcessMetadata(items) {
    try {
      const results = [];
      
      for (const item of items) {
        try {
          const result = await this.prepareMetadata(
            item.name,
            item.description,
            item.imagePath,
            item.attributes || []
          );
          results.push({
            success: true,
            data: result
          });
        } catch (error) {
          results.push({
            success: false,
            error: error.message,
            item
          });
        }
      }
      
      return results;
    } catch (error) {
      console.error('批量处理元数据时出错:', error);
      throw error;
    }
  }
}

// 使用示例
async function exampleUsage() {
  const storage = new NFTMetadataStorage();
  
  try {
    // 准备单个NFT元数据
    const metadataResult = await storage.prepareMetadata(
      '安全NFT示例',
      '这是一个使用IPFS安全存储的NFT示例',
      './nft_image.jpg',
      [
        { trait_type: '安全性', value: '高' },
        { trait_type: '存储方式', value: 'IPFS' },
        { trait_type: '创建年份', value: 2025 }
      ]
    );
    
    console.log('元数据已成功上传到IPFS:');
    console.log(`- 元数据CID: ${metadataResult.metadataCID}`);
    console.log(`- 图片CID: ${metadataResult.imageCID}`);
    console.log(`- 完整URI: ${metadataResult.metadataURI}`);
    
    // 创建备份
    const backupFile = await storage.createMetadataBackup(
      metadataResult.metadataCID,
      './nft_backups'
    );
    console.log(`元数据已备份到: ${backupFile}`);
    
    // 验证元数据
    const validation = storage.validateMetadata(metadataResult.metadata);
    console.log('元数据验证:', validation.isValid ? '通过' : `失败: ${validation.message}`);
  } catch (error) {
    console.error('操作失败:', error);
  }
}

// NFT授权管理工具
class NFTApprovalManager {
  constructor(provider, walletAddress) {
    this.provider = provider;
    this.walletAddress = walletAddress;
    this.erc721Abi = [
      'function isApprovedForAll(address owner, address operator) external view returns (bool)',
      'function getApproved(uint256 tokenId) external view returns (address)',
      'function setApprovalForAll(address operator, bool approved) external'
    ];
    this.erc1155Abi = [
      'function isApprovedForAll(address account, address operator) external view returns (bool)',
      'function setApprovalForAll(address operator, bool approved) external'
    ];
    this.knownMarketplaces = [
      '0x7Be8076f4EA4A4AD08075C2508e481d6C946D12b', // OpenSea Seaport
      '0x1E0049783F008A0085193E00003D00cd54003c71', // OpenSea Conduit
      '0x00000000006c3852cbEf3e08E8dF289169EdE581', // Rarible
      // 更多已知市场地址
    ];
  }
  
  // 检查ERC-721授权
  async checkERC721Approvals(contractAddress) {
    try {
      const contract = new ethers.Contract(contractAddress, this.erc721Abi, this.provider);
      
      // 1. 检查全局授权
      const globalApprovals = [];
      for (const marketplace of this.knownMarketplaces) {
        const isApproved = await contract.isApprovedForAll(this.walletAddress, marketplace);
        if (isApproved) {
          globalApprovals.push(marketplace);
        }
      }
      
      // 2. 检查单个token授权（需要知道tokenId）
      // 注意：在实际应用中，需要先获取用户拥有的所有tokenId
      
      return {
        contract: contractAddress,
        globalApprovals,
        tokenSpecificApprovals: [], // 需要单独查询
        hasUnnecessaryApprovals: globalApprovals.length > 0
      };
    } catch (error) {
      console.error(`检查ERC-721合约 ${contractAddress} 授权时出错:`, error);
      return { contract: contractAddress, error: error.message };
    }
  }
  
  // 检查ERC-1155授权
  async checkERC1155Approvals(contractAddress) {
    try {
      const contract = new ethers.Contract(contractAddress, this.erc1155Abi, this.provider);
      
      // 检查全局授权
      const globalApprovals = [];
      for (const marketplace of this.knownMarketplaces) {
        const isApproved = await contract.isApprovedForAll(this.walletAddress, marketplace);
        if (isApproved) {
          globalApprovals.push(marketplace);
        }
      }
      
      return {
        contract: contractAddress,
        globalApprovals,
        hasUnnecessaryApprovals: globalApprovals.length > 0
      };
    } catch (error) {
      console.error(`检查ERC-1155合约 ${contractAddress} 授权时出错:`, error);
      return { contract: contractAddress, error: error.message };
    }
  }
  
  // 撤销ERC-721全局授权
  async revokeERC721Approval(contractAddress, operator, signer) {
    try {
      const contract = new ethers.Contract(contractAddress, this.erc721Abi, signer);
      
      const tx = await contract.setApprovalForAll(operator, false);
      await tx.wait();
      
      return {
        success: true,
        transactionHash: tx.hash,
        message: `已成功撤销对 ${operator} 的全局授权`
      };
    } catch (error) {
      console.error(`撤销授权时出错:`, error);
      return {
        success: false,
        error: error.message
      };
    }
  }
  
  // 撤销ERC-1155全局授权
  async revokeERC1155Approval(contractAddress, operator, signer) {
    try {
      const contract = new ethers.Contract(contractAddress, this.erc1155Abi, signer);
      
      const tx = await contract.setApprovalForAll(operator, false);
      await tx.wait();
      
      return {
        success: true,
        transactionHash: tx.hash,
        message: `已成功撤销对 ${operator} 的全局授权`
      };
    } catch (error) {
      console.error(`撤销授权时出错:`, error);
      return {
        success: false,
        error: error.message
      };
    }
  }
  
  // 批量撤销所有授权
  async revokeAllApprovals(contracts, signer) {
    const results = [];
    
    for (const contractInfo of contracts) {
      try {
        let result;
        
        if (contractInfo.type === 'ERC721') {
          result = await this.revokeERC721Approval(
            contractInfo.address,
            contractInfo.operator,
            signer
          );
        } else if (contractInfo.type === 'ERC1155') {
          result = await this.revokeERC1155Approval(
            contractInfo.address,
            contractInfo.operator,
            signer
          );
        }
        
        results.push({
          contract: contractInfo.address,
          operator: contractInfo.operator,
          ...result
        });
      } catch (error) {
        results.push({
          contract: contractInfo.address,
          operator: contractInfo.operator,
          success: false,
          error: error.message
        });
      }
    }
    
    return results;
  }
  
  // 获取用户拥有的NFT合约列表
  async getUserNFTContracts() {
    try {
      // 在实际应用中，这里应该调用区块链API或NFT聚合器API
      // 例如：使用The Graph查询用户拥有的所有NFT合约
      // 这里仅作为示例返回模拟数据
      return [
        {
          address: '0xContract1',
          name: 'Collection 1',
          type: 'ERC721'
        },
        {
          address: '0xContract2',
          name: 'Collection 2',
          type: 'ERC1155'
        }
      ];
    } catch (error) {
      console.error('获取用户NFT合约列表时出错:', error);
      return [];
    }
  }
  
  // 全面检查所有授权
  async comprehensiveApprovalCheck() {
    try {
      const contracts = await this.getUserNFTContracts();
      const results = [];
      
      for (const contract of contracts) {
        let approvals;
        
        if (contract.type === 'ERC721') {
          approvals = await this.checkERC721Approvals(contract.address);
        } else if (contract.type === 'ERC1155') {
          approvals = await this.checkERC1155Approvals(contract.address);
        }
        
        results.push({
          ...contract,
          approvals
        });
      }
      
      // 计算统计信息
      const totalContracts = results.length;
      const contractsWithApprovals = results.filter(r => 
        r.approvals && r.approvals.hasUnnecessaryApprovals
      ).length;
      
      return {
        contracts: results,
        summary: {
          totalContracts,
          contractsWithApprovals,
          recommendation: contractsWithApprovals > 0 
            ? '建议撤销不必要的授权以提高安全性' 
            : '您的授权状态良好'
        }
      };
    } catch (error) {
      console.error('全面检查授权时出错:', error);
      throw error;
    }
  }
  
  // 验证操作安全性
  isSafeOperator(operator) {
    // 检查是否为已知安全的市场或平台
    return this.knownMarketplaces.includes(operator);
  }
  
  // 获取安全建议
  getSecurityRecommendations(approvalCheckResults) {
    const recommendations = [];
    
    if (approvalCheckResults.summary.contractsWithApprovals > 0) {
      recommendations.push('撤销不使用平台的授权');
    }
    
    // 检查是否有未知地址的授权
    for (const contract of approvalCheckResults.contracts) {
      if (contract.approvals && contract.approvals.globalApprovals) {
        for (const operator of contract.approvals.globalApprovals) {
          if (!this.isSafeOperator(operator)) {
            recommendations.push(`特别注意: 合约 ${contract.name} 授权给了未知地址 ${operator}`);
          }
        }
      }
    }
    
    // 添加一般安全建议
    recommendations.push('定期检查并撤销不必要的授权');
    recommendations.push('使用硬件钱包保护高价值NFT');
    recommendations.push('交易前验证市场平台的合法性');
    
    return recommendations;
  }
}

// 使用示例
async function manageNFTApprovals() {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_INFURA_KEY');
  const walletAddress = '0xYOUR_WALLET_ADDRESS';
  
  const manager = new NFTApprovalManager(provider, walletAddress);
  
  try {
    // 全面检查所有授权
    const approvalCheckResults = await manager.comprehensiveApprovalCheck();
    
    console.log('授权检查结果:');
    console.log(`- 总合约数: ${approvalCheckResults.summary.totalContracts}`);
    console.log(`- 有授权的合约数: ${approvalCheckResults.summary.contractsWithApprovals}`);
    
    // 获取安全建议
    const recommendations = manager.getSecurityRecommendations(approvalCheckResults);
    console.log('\n安全建议:');
    recommendations.forEach((rec, index) => console.log(`${index + 1}. ${rec}`));
    
    // 如果需要撤销授权，需要用户签名
    // const signer = provider.getSigner(); // 需要用户连接钱包
    // const revokeResults = await manager.revokeAllApprovals(contractsToRevoke, signer);
  } catch (error) {
    console.error('管理NFT授权时出错:', error);
  }
}

// 版权保护NFT合约示例
contract CopyrightProtectedNFT is ERC721, Ownable {
    // 版权信息结构
    struct CopyrightInfo {
        string creatorName;
        string creatorContact;
        uint256 creationDate;
        string licenseType; // 如CC BY-NC, 商业许可等
        string licenseTerms; // 详细许可条款URL
        bytes signature; // 创作者签名
    }
    
    // 每个NFT的版权信息
    mapping(uint256 => CopyrightInfo) private _copyrightInfo;
    
    // 版权验证事件
    event CopyrightInfoSet(uint256 indexed tokenId, address indexed creator);
    event CopyrightVerified(uint256 indexed tokenId, bool isValid);
    
    constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
    
    // 设置版权信息
    function setCopyrightInfo(
        uint256 tokenId,
        string calldata creatorName,
        string calldata creatorContact,
        string calldata licenseType,
        string calldata licenseTerms,
        bytes calldata signature
    ) external onlyOwner {
        require(_exists(tokenId), "Token不存在");
        
        _copyrightInfo[tokenId] = CopyrightInfo({
            creatorName: creatorName,
            creatorContact: creatorContact,
            creationDate: block.timestamp,
            licenseType: licenseType,
            licenseTerms: licenseTerms,
            signature: signature
        });
        
        emit CopyrightInfoSet(tokenId, owner());
    }
    
    // 获取版权信息
    function getCopyrightInfo(uint256 tokenId) public view returns (CopyrightInfo memory) {
        require(_exists(tokenId), "Token不存在");
        return _copyrightInfo[tokenId];
    }
    
    // 验证版权签名
    function verifyCopyrightSignature(
        uint256 tokenId,
        address expectedCreator
    ) public view returns (bool) {
        require(_exists(tokenId), "Token不存在");
        
        CopyrightInfo memory info = _copyrightInfo[tokenId];
        
        // 实现签名验证逻辑
        // 注意：这只是示例，实际实现需要根据签名算法调整
        // 通常需要哈希化版权信息，然后验证签名
        
        // 这里简单模拟验证
        bool isValid = info.signature.length > 0; // 实际应验证签名
        
        return isValid;
    }
    
    // 更新许可条款
    function updateLicenseTerms(uint256 tokenId, string calldata newTerms) external onlyOwner {
        require(_exists(tokenId), "Token不存在");
        _copyrightInfo[tokenId].licenseTerms = newTerms;
    }
    
    // 查询特定创作者的NFT
    function tokensByCreator(string calldata creatorName) public view returns (uint256[] memory) {
        uint256 totalSupply = totalSupply();
        uint256[] memory result = new uint256[](totalSupply);
        uint256 count = 0;
        
        for (uint256 i = 1; i <= totalSupply; i++) {
            if (_exists(i) && 
                keccak256(bytes(_copyrightInfo[i].creatorName)) == keccak256(bytes(creatorName))) {
                result[count] = i;
                count++;
            }
        }
        
        // 调整数组大小
        assembly {
            mstore(result, count)
        }
        
        return result;
    }
    
    // 版权转让
    function transferCopyright(
        uint256 tokenId,
        string calldata newCreatorName,
        string calldata newCreatorContact,
        bytes calldata newSignature
    ) external {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "未授权");
        
        CopyrightInfo memory info = _copyrightInfo[tokenId];
        
        // 更新版权信息
        _copyrightInfo[tokenId] = CopyrightInfo({
            creatorName: newCreatorName,
            creatorContact: newCreatorContact,
            creationDate: info.creationDate, // 保留原创作日期
            licenseType: info.licenseType,
            licenseTerms: info.licenseTerms,
            signature: newSignature
        });
        
        emit CopyrightInfoSet(tokenId, _msgSender());
    }
    
    // 批量设置版权信息
    function batchSetCopyrightInfo(
        uint256[] calldata tokenIds,
        string calldata creatorName,
        string calldata creatorContact,
        string calldata licenseType,
        string calldata licenseTerms,
        bytes calldata signature
    ) external onlyOwner {
        for (uint i = 0; i < tokenIds.length; i++) {
            uint256 tokenId = tokenIds[i];
            setCopyrightInfo(
                tokenId,
                creatorName,
                creatorContact,
                licenseType,
                licenseTerms,
                signature
            );
        }
    }
}