neozipkit 0.1.1 → 0.2.1

package/src/blockchain/ZipKitVerifier.ts

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+
+/**
+ * ZipKitVerifier - Handles NFT token verification for ZIP files
+ * Verifier API for NZIP-NFT smart contract.
+ */
+
+import { ethers } from 'ethers';
+import { NZIP_CONTRACT_ABI, CONTRACT_CONFIGS } from './contracts';
+import type { TokenMetadata } from './types';
+
+// Network configurations
+const NETWORK_CONFIGS = {
+  'base-sepolia': {
+    name: 'Base Sepolia',
+    rpcUrl: 'https://sepolia.base.org',
+    contractAddress: CONTRACT_CONFIGS[84532].address, // Use real contract address
+    explorerUrl: 'https://sepolia.basescan.org',
+    chainId: 84532
+  },
+  'base-mainnet': {
+    name: 'Base Mainnet',
+    rpcUrl: 'https://mainnet.base.org',
+    contractAddress: CONTRACT_CONFIGS[8453].address, // Use real contract address
+    explorerUrl: 'https://basescan.org',
+    chainId: 8453
+  }
+};
+
+export interface VerificationOptions {
+  debug?: boolean;
+  skipHash?: boolean;
+}
+
+export interface VerificationResult {
+  success: boolean;
+  message: string;
+  tokenMetadata?: TokenMetadata;
+  verificationDetails?: {
+    tokenId: string;
+    network: string;
+    contractAddress: string;
+    merkleRoot: string;
+    mintDate: string;
+    calculatedMerkleRoot?: string;
+    declaredMerkleRoot?: string;
+    merkleRootMatch?: boolean;
+    onChainValid?: boolean;
+  };
+  errorDetails?: {
+    errorType: 'METADATA_ERROR' | 'MERKLE_ERROR' | 'NETWORK_ERROR' | 'CONTRACT_ERROR';
+    networkName?: string;
+    rpcUrl?: string;
+    contractAddress?: string;
+    tokenId?: string;
+    merkleRoot?: string;
+  };
+}
+
+/**
+ * Blockchain Token Verifier for ZIP files
+ */
+export class ZipKitVerifier {
+  private debug: boolean;
+  
+  constructor(options: VerificationOptions = {}) {
+    this.debug = options.debug || false;
+    
+    if (this.debug) {
+      console.log(`[DEBUG] ZipKitVerifier initialized`);
+    }
+  }
+
+  /**
+   * Extract and validate token metadata from ZIP
+   */
+  async extractTokenMetadata(tokenBuffer: Buffer): Promise<{ success: boolean; metadata?: TokenMetadata; error?: string }> {
+    try {
+      if (this.debug) {
+        console.log(`[DEBUG] Extracting token metadata from buffer (${tokenBuffer.length} bytes)`);
+      }
+
+      const tokenData = JSON.parse(tokenBuffer.toString('utf8'));
+      
+      // Validate required fields
+      const requiredFields = ['tokenId', 'contractAddress', 'network'];
+      for (const field of requiredFields) {
+        if (!tokenData[field]) {
+          if (this.debug) {
+            console.log(`[DEBUG] Missing required field: ${field}`);
+          }
+          return { 
+            success: false, 
+            error: `Missing required field: ${field}` 
+          };
+        }
+      }
+
+      if (this.debug) {
+        console.log(`[DEBUG] Token metadata extracted successfully`);
+        console.log(`[DEBUG] Token ID: ${tokenData.tokenId}, Network: ${tokenData.network}`);
+      }
+
+      return { 
+        success: true, 
+        metadata: tokenData as TokenMetadata 
+      };
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Invalid JSON format';
+      
+      if (this.debug) {
+        console.log(`[DEBUG] Failed to parse token metadata: ${errorMessage}`);
+      }
+
+      return { 
+        success: false, 
+        error: `Invalid token metadata format: ${errorMessage}` 
+      };
+    }
+  }
+
+  /**
+   * Map network name to RPC configuration
+   */
+  private getNetworkConfig(networkName: string): { success: boolean; config?: any; error?: string } {
+    const normalizedName = networkName.toLowerCase();
+    
+    if (this.debug) {
+      console.log(`[DEBUG] Looking up network config for: ${normalizedName}`);
+    }
+
+    // Map various network name variations to our configs
+    if (normalizedName.includes('sepolia')) {
+      return { success: true, config: NETWORK_CONFIGS['base-sepolia'] };
+    } else if (normalizedName.includes('base') && !normalizedName.includes('sepolia')) {
+      return { success: true, config: NETWORK_CONFIGS['base-mainnet'] };
+    }
+
+    if (this.debug) {
+      console.log(`[DEBUG] Unsupported network: ${normalizedName}`);
+    }
+
+    return { 
+      success: false, 
+      error: `Unsupported network: ${networkName}` 
+    };
+  }
+
+  /**
+   * Perform merkle root comparison
+   */
+  private compareMerkleRoots(calculated: string | null, declared: string | null): {
+    success: boolean;
+    match: boolean;
+    calculated?: string;
+    declared?: string;
+    error?: string;
+  } {
+    if (this.debug) {
+      console.log(`[DEBUG] Comparing merkle roots`);
+      console.log(`[DEBUG] Calculated: ${calculated || 'null'}`);
+      console.log(`[DEBUG] Declared: ${declared || 'null'}`);
+    }
+
+    if (!calculated) {
+      return {
+        success: false,
+        match: false,
+        error: 'Cannot calculate merkle root from archive contents'
+      };
+    }
+
+    if (!declared) {
+      return {
+        success: false,
+        match: false,
+        calculated,
+        error: 'No merkle root found in token metadata'
+      };
+    }
+
+    const match = calculated === declared;
+    
+    if (this.debug) {
+      console.log(`[DEBUG] Merkle root match: ${match}`);
+    }
+
+    return {
+      success: true,
+      match,
+      calculated,
+      declared
+    };
+  }
+
+  /**
+   * Verify token against blockchain
+   */
+  async verifyOnChain(
+    tokenId: string, 
+    contractAddress: string, 
+    networkConfig: any, 
+    merkleRoot: string
+  ): Promise<{ success: boolean; isValid?: boolean; error?: string }> {
+    try {
+      if (this.debug) {
+        console.log(`[DEBUG] Starting on-chain verification`);
+        console.log(`[DEBUG] Token ID: ${tokenId}, Contract: ${contractAddress}`);
+        console.log(`[DEBUG] Network: ${networkConfig.name}, RPC: ${networkConfig.rpcUrl}`);
+      }
+
+      const provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+      const contract = new ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, provider);
+
+      if (this.debug) {
+        console.log(`[DEBUG] Calling contract.verifyZipFile(${tokenId}, ${merkleRoot.substring(0, 10)}...)`);
+      }
+
+      const isValid: boolean = await contract.verifyZipFile(tokenId, merkleRoot);
+
+      if (this.debug) {
+        console.log(`[DEBUG] On-chain verification result: ${isValid}`);
+      }
+
+      return { success: true, isValid };
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Network error';
+      
+      if (this.debug) {
+        console.log(`[DEBUG] On-chain verification failed: ${errorMessage}`);
+      }
+
+      return { 
+        success: false, 
+        error: errorMessage 
+      };
+    }
+  }
+
+  /**
+   * Complete verification process
+   */
+  async verifyToken(
+    tokenMetadata: TokenMetadata,
+    calculatedMerkleRoot: string | null,
+    options: VerificationOptions = {}
+  ): Promise<VerificationResult> {
+    try {
+      if (this.debug) {
+        console.log(`[DEBUG] Starting complete token verification`);
+      }
+
+      // Get network configuration
+      const networkResult = this.getNetworkConfig(tokenMetadata.network);
+      if (!networkResult.success || !networkResult.config) {
+        return {
+          success: false,
+          message: networkResult.error || 'Unknown network error',
+          errorDetails: {
+            errorType: 'NETWORK_ERROR',
+            networkName: tokenMetadata.network
+          }
+        };
+      }
+
+      const networkConfig = networkResult.config;
+      const declaredMerkleRoot = tokenMetadata.merkleRoot;
+
+      // Compare merkle roots if hash verification is not skipped
+      if (!options.skipHash) {
+        const merkleComparison = this.compareMerkleRoots(calculatedMerkleRoot, declaredMerkleRoot);
+        
+        if (!merkleComparison.success) {
+          return {
+            success: false,
+            message: merkleComparison.error || 'Merkle root verification failed',
+            errorDetails: {
+              errorType: 'MERKLE_ERROR',
+              merkleRoot: declaredMerkleRoot || 'null'
+            }
+          };
+        }
+
+        if (!merkleComparison.match) {
+          return {
+            success: false,
+            message: 'Archive integrity verification FAILED - merkle root mismatch',
+            errorDetails: {
+              errorType: 'MERKLE_ERROR',
+              merkleRoot: `calculated: ${merkleComparison.calculated}, declared: ${merkleComparison.declared}`
+            }
+          };
+        }
+      }
+
+      // Perform on-chain verification
+      const merkleToVerify = calculatedMerkleRoot;
+      if (!merkleToVerify) {
+        return {
+          success: false,
+          message: 'No merkle root available for verification',
+          errorDetails: {
+            errorType: 'MERKLE_ERROR'
+          }
+        };
+      }
+
+      const onChainResult = await this.verifyOnChain(
+        tokenMetadata.tokenId,
+        tokenMetadata.contractAddress,
+        networkConfig,
+        merkleToVerify
+      );
+
+      if (!onChainResult.success) {
+        return {
+          success: false,
+          message: `Blockchain verification failed: ${onChainResult.error}`,
+          errorDetails: {
+            errorType: 'CONTRACT_ERROR',
+            networkName: tokenMetadata.network,
+            rpcUrl: networkConfig.rpcUrl,
+            contractAddress: tokenMetadata.contractAddress,
+            tokenId: tokenMetadata.tokenId
+          }
+        };
+      }
+
+      if (!onChainResult.isValid) {
+        return {
+          success: false,
+          message: 'Blockchain verification FAILED - token or merkle root invalid',
+          errorDetails: {
+            errorType: 'CONTRACT_ERROR',
+            tokenId: tokenMetadata.tokenId,
+            contractAddress: tokenMetadata.contractAddress,
+            merkleRoot: merkleToVerify
+          }
+        };
+      }
+
+      // Success - create verification details
+      const mintDate = tokenMetadata.mintDate || 
+                      (tokenMetadata.creationTimestamp ? new Date(tokenMetadata.creationTimestamp * 1000).toLocaleString() : '') ||
+                      '8/01/2025 at 1:00:00 PM'; // fallback
+
+      return {
+        success: true,
+        message: 'Archive integrity VERIFIED against blockchain records',
+        tokenMetadata,
+        verificationDetails: {
+          tokenId: tokenMetadata.tokenId,
+          network: tokenMetadata.network,
+          contractAddress: tokenMetadata.contractAddress,
+          merkleRoot: merkleToVerify,
+          mintDate,
+          calculatedMerkleRoot: calculatedMerkleRoot || undefined,
+          declaredMerkleRoot: declaredMerkleRoot || undefined,
+          merkleRootMatch: !options.skipHash ? calculatedMerkleRoot === declaredMerkleRoot : undefined,
+          onChainValid: true
+        }
+      };
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown verification error';
+      
+      if (this.debug) {
+        console.log(`[DEBUG] Verification process failed: ${errorMessage}`);
+      }
+
+      return {
+        success: false,
+        message: `Tokenization verification failed: ${errorMessage}`,
+        errorDetails: {
+          errorType: 'METADATA_ERROR'
+        }
+      };
+    }
+  }
+}