neozipkit 0.1.1 → 0.3.0

package/src/server/blockchain/TokenVerifier.ts

@@ -1,453 +0,0 @@
-// ======================================
-//	TokenVerifier.ts
-//  Blockchain token verification utilities for ZIP archives
-//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
-// ======================================
-
-import * as fs from 'fs';
-import * as path from 'path';
-import ZipKitServer from '../platform/server/ZipKitServer';
-import ZipEntry from '../../shared/ZipEntry';
-import { NZipTokenInfo } from './types';
-import { TOKENIZED_METADATA } from '../../shared/constants/Headers';
-import { ZipMetadata } from './ZipMetadata';
-import { 
-  createTokenCertificate, 
-  saveCertificate,
-  TokenInfo, 
-  BlockchainVerification, 
-  WalletInfo,
-  ZipFileInfo 
-} from './CertificateToken';
-
-// Network configuration for blockchain queries
-const NETWORK_CONFIG: Record<string, any> = {
-  'Base Sepolia': {
-    rpcUrls: [
-      'https://sepolia.base.org',
-      'https://base-sepolia.g.alchemy.com/v2/demo',
-      'https://base-sepolia-rpc.publicnode.com',
-      'https://base-sepolia.blockpi.network/v1/rpc/public'
-    ]
-  },
-  'Base Mainnet': {
-    rpcUrls: [
-      'https://mainnet.base.org',
-      'https://base-mainnet.g.alchemy.com/v2/demo',
-      'https://base-rpc.publicnode.com',
-      'https://base.blockpi.network/v1/rpc/public'
-    ]
-  }
-};
-
-export interface TokenVerificationOptions {
-  skipHash?: boolean;
-  skipToken?: boolean;
-  generateCertificate?: boolean;
-  zipFileName?: string;
-}
-
-export interface TokenVerificationResult {
-  isTokenized: boolean;
-  tokenMetadata: NZipTokenInfo | null;
-  calculatedMerkleRoot: string | null;
-  blockchainMerkleRoot: string | null;
-  verificationPassed: boolean;
-  certificatePath?: string;
-}
-
-/**
- * Checks if the ZIP file contains NFT token metadata and verifies the merkle root
- */
-export async function checkForTokenization(
-  zipKit: ZipKitServer,
-  options: TokenVerificationOptions = {}
-): Promise<TokenVerificationResult> {
-  const zipEntries = zipKit.getDirectory() as ZipEntry[];
-  
-  // Look for the tokenized metadata file
-  const tokenEntry = zipEntries.find(entry => entry.filename === TOKENIZED_METADATA);
-  
-  if (tokenEntry) {
-    console.log('\n🔍 Tokenized ZIP detected!');
-    console.log('═'.repeat(60));
-    
-    try {
-      // Extract the token metadata
-      console.log('📄 Reading token metadata...');
-      const tokenData = await zipKit.extract(tokenEntry);
-      
-      if (tokenData) {
-        const tokenContent = tokenData.toString('utf8');
-        const tokenMetadata = JSON.parse(tokenContent);
-        
-        // Validate token metadata structure - only accept full NFT tokens
-        if (ZipMetadata.validateTokenInfo(tokenMetadata) && tokenMetadata) {
-          console.log('✅ Valid NFT token metadata found');
-          
-          // Display token information
-          console.log(ZipMetadata.createTokenSummary(tokenMetadata));
-          
-          // Automatically verify token merkle root unless skipped or hash calculation is disabled
-          if (options.skipHash) {
-            console.log('\n⏭️  Token verification skipped (--skip-hash prevents merkle root calculation)');
-            console.log('💡 Use -H flag to enable hash calculation and token verification');
-            
-            return {
-              isTokenized: true,
-              tokenMetadata,
-              calculatedMerkleRoot: null,
-              blockchainMerkleRoot: null,
-              verificationPassed: false
-            };
-          } else if (options.skipToken) {
-            console.log('\n⏭️  Token verification skipped (--skip-token flag)');
-            console.log('⚠️  WARNING: Archive integrity cannot be verified without token validation');
-            
-            return {
-              isTokenized: true,
-              tokenMetadata,
-              calculatedMerkleRoot: null,
-              blockchainMerkleRoot: null,
-              verificationPassed: false
-            };
-          } else {
-            console.log('\n🔒 Verifying archive integrity against blockchain...');
-            const calculatedMerkleRoot = calculateMerkleRootExcludingToken(zipKit);
-            
-            if (calculatedMerkleRoot && tokenMetadata) {
-              // Query blockchain for the actual merkle root (full NFT tokens only)
-              console.log('🌐 Querying blockchain for stored merkle root...');
-              const blockchainMerkleRoot = await queryBlockchainMerkleRoot(tokenMetadata);
-              
-              if (blockchainMerkleRoot) {
-                console.log(`Blockchain Merkle Root: ${blockchainMerkleRoot}`);
-                console.log(`Calculated Merkle Root: ${calculatedMerkleRoot}`);
-                
-                if (blockchainMerkleRoot === calculatedMerkleRoot) {
-                  console.log('✅ BLOCKCHAIN VERIFICATION: PASSED');
-                  console.log('   Archive contents match the blockchain-recorded merkle root!');
-                  
-                  // Generate certificate if requested
-                  let certificatePath: string | undefined;
-                  if (options.generateCertificate) {
-                    certificatePath = await generateCertificate(
-                      tokenMetadata,
-                      options.zipFileName || 'unknown.zip',
-                      zipEntries,
-                      {
-                        merkleRootMatches: true,
-                        blockchainMerkleRoot,
-                        calculatedMerkleRoot,
-                        verificationStatus: 'PASSED',
-                        verificationTime: Math.floor(Date.now() / 1000)
-                      }
-                    );
-                  }
-                  
-                  return {
-                    isTokenized: true,
-                    tokenMetadata,
-                    calculatedMerkleRoot,
-                    blockchainMerkleRoot,
-                    verificationPassed: true,
-                    certificatePath
-                  };
-                } else {
-                  console.log('❌ BLOCKCHAIN VERIFICATION: FAILED');
-                  console.log('   WARNING: Archive contents do not match the blockchain record!');
-                  console.log('   This archive may have been tampered with or corrupted.');
-                  
-                  // Generate certificate for failed verification if requested
-                  let certificatePath: string | undefined;
-                  if (options.generateCertificate) {
-                    certificatePath = await generateCertificate(
-                      tokenMetadata,
-                      options.zipFileName || 'unknown.zip',
-                      zipEntries,
-                      {
-                        merkleRootMatches: false,
-                        blockchainMerkleRoot,
-                        calculatedMerkleRoot,
-                        verificationStatus: 'FAILED',
-                        verificationTime: Math.floor(Date.now() / 1000)
-                      }
-                    );
-                  }
-                  
-                  return {
-                    isTokenized: true,
-                    tokenMetadata,
-                    calculatedMerkleRoot,
-                    blockchainMerkleRoot,
-                    verificationPassed: false,
-                    certificatePath
-                  };
-                }
-              } else {
-                console.log('❌ BLOCKCHAIN VERIFICATION: FAILED');
-                console.log('   Could not retrieve merkle root from blockchain');
-                console.log('   Token metadata may be invalid or network unreachable');
-                
-                // Handle unavailable blockchain verification
-                let certificatePath: string | undefined;
-                if (options.generateCertificate && tokenMetadata) {
-                  certificatePath = await generateCertificate(
-                    tokenMetadata,
-                    options.zipFileName || 'unknown.zip',
-                    zipEntries,
-                    {
-                      merkleRootMatches: false,
-                      blockchainMerkleRoot: "Unavailable",
-                      calculatedMerkleRoot: zipKit.getMerkleRoot() || 'Unable to calculate',
-                      verificationStatus: 'UNAVAILABLE',
-                      verificationTime: Math.floor(Date.now() / 1000)
-                    }
-                  );
-                }
-                
-                return {
-                  isTokenized: true,
-                  tokenMetadata,
-                  calculatedMerkleRoot,
-                  blockchainMerkleRoot: null,
-                  verificationPassed: false,
-                  certificatePath
-                };
-              }
-            }
-          }
-        } else {
-          console.log('❌ Invalid token metadata structure');
-          console.log('   This archive contains invalid or unsupported token metadata');
-          console.log('   Only full NFT tokens with blockchain verification are supported');
-          
-          return {
-            isTokenized: false,
-            tokenMetadata: null,
-            calculatedMerkleRoot: null,
-            blockchainMerkleRoot: null,
-            verificationPassed: false
-          };
-        }
-      } else {
-        console.log('❌ Could not read token metadata');
-        
-        return {
-          isTokenized: false,
-          tokenMetadata: null,
-          calculatedMerkleRoot: null,
-          blockchainMerkleRoot: null,
-          verificationPassed: false
-        };
-      }
-    } catch (error) {
-      console.error('❌ Error reading token metadata:', error);
-      
-      return {
-        isTokenized: false,
-        tokenMetadata: null,
-        calculatedMerkleRoot: null,
-        blockchainMerkleRoot: null,
-        verificationPassed: false
-      };
-    }
-    
-    console.log('═'.repeat(60));
-  } else {
-    console.log('\n📦 Standard ZIP archive (not tokenized)');
-    if (options.skipHash) {
-      console.log('⏭️  SHA-256 hash validation disabled');
-    }
-    
-    return {
-      isTokenized: false,
-      tokenMetadata: null,
-      calculatedMerkleRoot: null,
-      blockchainMerkleRoot: null,
-      verificationPassed: false
-    };
-  }
-  
-  // Fallback return for cases where calculatedMerkleRoot is null
-  return {
-    isTokenized: true,
-    tokenMetadata: null,
-    calculatedMerkleRoot: null,
-    blockchainMerkleRoot: null,
-    verificationPassed: false
-  };
-}
-
-/**
- * Queries the blockchain to get the actual merkle root stored in the smart contract
- */
-async function queryBlockchainMerkleRoot(tokenMetadata: NZipTokenInfo): Promise<string | null> {
-  try {
-    const { ethers } = await import('ethers');
-    
-    const networkConfig = NETWORK_CONFIG[tokenMetadata.network];
-    if (!networkConfig) {
-      console.log(`⚠️  Unsupported network: ${tokenMetadata.network}`);
-      return null;
-    }
-    
-    // Try multiple RPC endpoints
-    for (const rpcUrl of networkConfig.rpcUrls) {
-      try {
-        console.log(`   Trying RPC: ${rpcUrl}`);
-        const provider = new ethers.JsonRpcProvider(rpcUrl);
-        
-        // Test connection
-        await provider.getBlockNumber();
-        
-        // Use hardcoded ABI for NZIP NFT Contract v2.0
-        const CONTRACT_ABI = [
-          {
-            "inputs": [{"internalType": "uint256", "name": "tokenId", "type": "uint256"}],
-            "name": "getZipFileInfo",
-            "outputs": [
-              {
-                "components": [
-                  {"internalType": "string", "name": "fileName", "type": "string"},
-                  {"internalType": "string", "name": "merkleRootHash", "type": "string"},
-                  {"internalType": "string", "name": "ipfsHash", "type": "string"},
-                  {"internalType": "address", "name": "creator", "type": "address"},
-                  {"internalType": "uint256", "name": "creationTimestamp", "type": "uint256"},
-                  {"internalType": "uint256", "name": "tokenizationTime", "type": "uint256"},
-                  {"internalType": "uint256", "name": "blockNumber", "type": "uint256"}
-                ],
-                "internalType": "struct ZipFileNFT.ZipFileInfo",
-                "name": "",
-                "type": "tuple"
-              }
-            ],
-            "stateMutability": "view",
-            "type": "function"
-          }
-        ];
-        
-        // Create contract instance
-        const contract = new ethers.Contract(tokenMetadata.contractAddress, CONTRACT_ABI, provider);
-        
-        // Call getZipFileInfo to get the blockchain-stored merkle root
-        const zipInfo = await contract.getZipFileInfo(tokenMetadata.tokenId);
-        console.log(`   ✅ Connected to blockchain successfully`);
-        
-        return zipInfo.merkleRootHash;
-        
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.log(`   ❌ RPC failed: ${errorMessage.substring(0, 80)}...`);
-        continue;
-      }
-    }
-    
-    console.log(`⚠️  All RPC endpoints failed for network: ${tokenMetadata.network}`);
-    return null;
-    
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.log(`⚠️  Blockchain query error: ${errorMessage}`);
-    return null;
-  }
-}
-
-/**
- * Calculates the merkle root excluding the token metadata file
- * This represents the original content that was tokenized
- */
-function calculateMerkleRootExcludingToken(zipKit: ZipKitServer): string | null {
-  try {
-    // Get all entries except the token file
-    const zipEntries = zipKit.getDirectory() as ZipEntry[];
-    const contentEntries = zipEntries.filter(entry => entry.filename !== TOKENIZED_METADATA);
-    
-    if (contentEntries.length === 0) {
-      console.log('⚠️  No content files found for merkle root calculation');
-      return null;
-    }
-    
-    console.log(`📊 Calculating merkle root for ${contentEntries.length} content files...`);
-    
-    // For each content entry, ensure we have SHA-256 hash calculated
-    for (const entry of contentEntries) {
-      if (!entry.sha256) {
-        // Extract the file to calculate its SHA-256 hash
-        try {
-          const fileData = zipKit.extract(entry);
-          // The extraction process should calculate and set the SHA-256 hash
-          console.log(`   Calculated SHA-256 for: ${entry.filename}`);
-        } catch (error) {
-          console.log(`   ⚠️  Could not process: ${entry.filename}`);
-          return null; // Cannot calculate merkle root without all hashes
-        }
-      }
-    }
-    
-    // Now calculate the merkle root from the content files
-    const merkleRoot = zipKit.getMerkleRoot();
-    
-    return merkleRoot;
-  } catch (error) {
-    console.error('Error calculating merkle root:', error);
-    return null;
-  }
-}
-
-/**
- * Generates a token certificate
- */
-async function generateCertificate(
-  tokenMetadata: NZipTokenInfo,
-  zipFileName: string,
-  zipEntries: ZipEntry[],
-  blockchainVerification: BlockchainVerification
-): Promise<string> {
-  console.log('\n📜 Generating Token Certificate...');
-  
-  try {
-    // Prepare token information
-    const tokenInfo: TokenInfo = {
-      tokenId: tokenMetadata.tokenId,
-      contractAddress: tokenMetadata.contractAddress,
-      network: tokenMetadata.network,
-      transactionHash: tokenMetadata.transactionHash
-    };
-    
-    // Prepare file information from ZIP entries
-    const zipFiles: ZipFileInfo[] = [];
-    for (const entry of zipEntries) {
-      // Skip the token file itself and directories
-      if (entry.filename !== TOKENIZED_METADATA && 
-          !entry.isDirectory && 
-          entry.sha256) {
-        zipFiles.push({
-          filename: entry.filename,
-          size: entry.uncompressedSize,
-          date: entry.toFormattedUTCDateString(),
-          hash: entry.sha256
-        });
-      }
-    }
-    
-    // Generate the certificate
-    const certificateHTML = createTokenCertificate(
-      tokenInfo,
-      zipFileName,
-      blockchainVerification,
-      undefined, // walletInfo
-      zipFiles
-    );
-    
-    // Save the certificate
-    const certPath = saveCertificate(zipFileName, certificateHTML);
-    console.log(`✅ Certificate generated: ${certPath}`);
-    
-    return certPath;
-    
-  } catch (error) {
-    console.error('❌ Failed to generate certificate:', error);
-    throw error;
-  }
-}