neozipkit 0.1.1

package/src/server/blockchain/TokenVerifier.ts

@@ -0,0 +1,453 @@
+// ======================================
+//	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;
+  }
+}