neozipkit 0.2.1 → 0.3.0

package/src/blockchain/ZipKitVerifier.ts

@@ -1,382 +0,0 @@
-#!/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'
-        }
-      };
-    }
-  }
-}

package/src/blockchain/contracts.ts

@@ -1,88 +0,0 @@
-// Contract addresses and configurations for different networks
-
-export interface ContractConfig {
-  address: string
-  network: string
-  chainId: number
-  explorerUrl: string
-  rpcUrls: string[]
-}
-
-// NZIP NFT Contract configurations by network
-export const CONTRACT_CONFIGS: Record<number, ContractConfig> = {
-  // Base Sepolia (Primary testnet)
-  84532: {
-    address: '0xFD76a5d420704F34d84b0767961835c43D7b30a8', // Production contract v2.0
-    network: 'Base Sepolia',
-    chainId: 84532,
-    explorerUrl: 'https://sepolia.basescan.org',
-    rpcUrls: [
-      'https://sepolia.base.org',
-      'https://base-sepolia.g.alchemy.com/v2/demo',
-      'https://base-sepolia-rpc.publicnode.com'
-    ]
-  },
-  
-  // Base Mainnet (Production)
-  8453: {
-    address: '0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60',
-    network: 'Base Mainnet',
-    chainId: 8453,
-    explorerUrl: 'https://basescan.org',
-    rpcUrls: [
-      'https://mainnet.base.org',
-      'https://base.drpc.org',
-      'https://base.gateway.tenderly.co'
-    ]
-  },
-  
-  // Ethereum Sepolia (Testnet) - disabled until NZIP is deployed
-  // 11155111: {
-  //   address: '0x0000000000000000000000000000000000000000',
-  //   network: 'Sepolia Testnet',
-  //   chainId: 11155111,
-  //   explorerUrl: 'https://sepolia.etherscan.io',
-  //   rpcUrls: []
-  // },
-  
-  // Ethereum Mainnet (Production) - disabled until NZIP is deployed
-  // 1: {
-  //   address: '0x0000000000000000000000000000000000000000',
-  //   network: 'Ethereum Mainnet',
-  //   chainId: 1,
-  //   explorerUrl: 'https://etherscan.io',
-  //   rpcUrls: []
-  // }
-}
-
-// Contract ABI (same for all networks)
-export const NZIP_CONTRACT_ABI = [
-  "function publicMintZipFile(string memory fileName, string memory merkleRootHash, uint256 creationTimestamp, string memory ipfsHash, string memory metadataURI) public returns (uint256)",
-  "function totalSupply() external view returns (uint256)",
-  "function getTokensByMerkleRoot(string memory merkleRoot) external view returns (uint256[])",
-  "function getZipFileInfo(uint256 tokenId) external view returns (tuple(string fileName, string merkleRootHash, string ipfsHash, address creator, uint256 creationTimestamp, uint256 tokenizationTime, uint256 blockNumber))",
-  "function ownerOf(uint256 tokenId) external view returns (address)",
-  "function balanceOf(address owner) external view returns (uint256)",
-  "function isZipFileTokenized(string memory merkleRootHash, uint256 creationTimestamp) external view returns (bool exists, uint256 tokenId)",
-  "function verifyZipFile(uint256 tokenId, string memory providedMerkleRoot) external view returns (bool isValid)",
-  "function getVersion() external pure returns (string memory)",
-  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)",
-  "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
-]
-
-// Default configuration (Base Sepolia for development)
-export const DEFAULT_NETWORK = 84532
-export const CURRENT_DEPLOYMENT = CONTRACT_CONFIGS[DEFAULT_NETWORK]
-
-// Helper functions
-export const getContractConfig = (chainId: number): ContractConfig => {
-  return CONTRACT_CONFIGS[chainId] || CURRENT_DEPLOYMENT
-}
-
-export const getSupportedNetworks = (): number[] => {
-  return Object.keys(CONTRACT_CONFIGS).map(Number)
-}
-
-export const isNetworkSupported = (chainId: number): boolean => {
-  return chainId in CONTRACT_CONFIGS
-}

package/src/blockchain/types.ts

@@ -1,91 +0,0 @@
-import type { Wallet, JsonRpcProvider } from 'ethers';
-
-// Wallet and network types
-export interface WalletInfo {
-  address: string;
-  privateKey: string;
-  mnemonic: string;
-}
-
-export interface NetworkConfig {
-  name: string;
-  rpcUrl: string;
-  chainId: number;
-  explorerUrl: string;
-}
-
-export interface WalletSetupResult {
-  wallet: Wallet | null;
-  provider: JsonRpcProvider | null;
-  success: boolean;
-  message?: string;
-}
-
-export interface MintingResult {
-  success: boolean;
-  message: string;
-  tokenId?: string;
-  txHash?: string;
-  creationTimestamp?: number;
-}
-
-export interface MintingOptions {
-  wallet?: string;
-  network: string;
-  mintToken: boolean;
-}
-
-// Canonical token metadata used across minting, verification, and ZIP embedding
-export interface TokenMetadata {
-  // Core identifiers
-  tokenId: string;
-  contractAddress: string;
-  network: string;
-  merkleRoot: string;
-
-  // Optional chain info
-  networkChainId?: number;
-  transactionHash?: string;
-  blockNumber?: number;
-
-  // Names and timestamps (support both archiveName/fileName and mintedAt/mintDate)
-  fileName?: string;
-  archiveName?: string;
-  mintedAt?: string;
-  mintDate?: string;
-  creationTimestamp?: number;
-
-  // Optional content link
-  ipfsHash?: string;
-
-  // Versioning
-  version?: string;
-}
-
-// Network configuration
-export const NETWORKS: Record<string, NetworkConfig> = {
-  'base': {
-    name: 'Base Mainnet',
-    rpcUrl: 'https://mainnet.base.org',
-    chainId: 8453,
-    explorerUrl: 'https://basescan.org'
-  },
-  'base-sepolia': {
-    name: 'Base Sepolia',
-    rpcUrl: 'https://sepolia.base.org',
-    chainId: 84532,
-    explorerUrl: 'https://sepolia.basescan.org'
-  },
-  'base-goerli': {
-    name: 'Base Goerli',
-    rpcUrl: 'https://goerli.base.org',
-    chainId: 84531,
-    explorerUrl: 'https://goerli.basescan.org'
-  },
-  'localhost': {
-    name: 'Localhost',
-    rpcUrl: 'http://localhost:8545',
-    chainId: 31337,
-    explorerUrl: 'http://localhost:8545'
-  }
-};