neozipkit 0.1.1 → 0.2.1

package/dist/blockchain/ZipKitVerifier.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ZipKitVerifier - Handles NFT token verification for ZIP files
+ * Verifier API for NZIP-NFT smart contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipKitVerifier = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+// Network configurations
+const NETWORK_CONFIGS = {
+    'base-sepolia': {
+        name: 'Base Sepolia',
+        rpcUrl: 'https://sepolia.base.org',
+        contractAddress: contracts_1.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: contracts_1.CONTRACT_CONFIGS[8453].address, // Use real contract address
+        explorerUrl: 'https://basescan.org',
+        chainId: 8453
+    }
+};
+/**
+ * Blockchain Token Verifier for ZIP files
+ */
+class ZipKitVerifier {
+    constructor(options = {}) {
+        this.debug = options.debug || false;
+        if (this.debug) {
+            console.log(`[DEBUG] ZipKitVerifier initialized`);
+        }
+    }
+    /**
+     * Extract and validate token metadata from ZIP
+     */
+    async extractTokenMetadata(tokenBuffer) {
+        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
+            };
+        }
+        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
+     */
+    getNetworkConfig(networkName) {
+        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
+     */
+    compareMerkleRoots(calculated, declared) {
+        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, contractAddress, networkConfig, merkleRoot) {
+        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_1.ethers.JsonRpcProvider(networkConfig.rpcUrl);
+            const contract = new ethers_1.ethers.Contract(contractAddress, contracts_1.NZIP_CONTRACT_ABI, provider);
+            if (this.debug) {
+                console.log(`[DEBUG] Calling contract.verifyZipFile(${tokenId}, ${merkleRoot.substring(0, 10)}...)`);
+            }
+            const isValid = 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, calculatedMerkleRoot, options = {}) {
+        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'
+                }
+            };
+        }
+    }
+}
+exports.ZipKitVerifier = ZipKitVerifier;

package/dist/{server/blockchain/WalletAnalyzer.d.ts → blockchain/ZipKitWallet.d.ts}

@@ -1,4 +1,11 @@
 import { ethers } from 'ethers';
+import { WalletSetupResult, MintingOptions } from './types';
+export interface CommonTokenConfig {
+    address: string;
+    name: string;
+    symbol: string;
+    type: 'ERC20' | 'ERC721';
+}
 export interface TokenInfo {
     address: string;
     name: string;
@@ -7,17 +14,6 @@ export interface TokenInfo {
     decimals?: number;
     type: 'ERC20' | 'ERC721' | 'NZIP';
 }
-export interface NZipTokenDetails {
-    tokenId: string;
-    merkleRootHash: string;
-    fileName: string;
-    timestamp: number;
-    tokenURI?: string;
-    creator: string;
-    creationTimestamp: number;
-    tokenizationTime: number;
-    ipfsHash?: string;
-}
 export interface WalletBasicInfo {
     ethBalance: string;
     transactionCount: number;
@@ -29,53 +25,45 @@ export interface TokenScanResult {
     foundTokens: number[];
     searchMethod: 'recent-events' | 'iteration' | 'common-ids' | 'none';
 }
-export interface CommonTokenConfig {
-    address: string;
-    name: string;
-    symbol: string;
-    type: 'ERC20' | 'ERC721';
+export interface NZipTokenDetails {
+    tokenId: string;
+    merkleRootHash: string;
+    fileName: string;
+    timestamp: number;
+    tokenURI?: string;
+    creator: string;
+    creationTimestamp: number;
+    tokenizationTime: number;
+    ipfsHash?: string;
+}
+export declare class ZipKitWallet {
+    private wallet;
+    private provider;
+    private promptUser;
+    private findExistingWallets;
+    private loadWalletFromFile;
+    setupWallet(options: MintingOptions): Promise<WalletSetupResult>;
+    private createNewWallet;
+    private connectToNetwork;
+    getWallet(): ethers.Wallet | null;
+    getProvider(): ethers.JsonRpcProvider | null;
+    isReady(): boolean;
+    isOnline(): boolean;
 }
 export declare class WalletAnalyzer {
     private provider;
     constructor(provider: ethers.JsonRpcProvider);
-    /**
-     * Get basic wallet information (balance, transaction count, etc.)
-     */
     getWalletBasics(address: string): Promise<WalletBasicInfo>;
-    /**
-     * Scan for NZIP tokens owned by an address using multiple methods
-     */
     scanForNZipTokens(contractAddress: string, ownerAddress: string): Promise<TokenScanResult>;
-    /**
-     * Get detailed information about NZIP tokens
-     */
     getNZipTokenDetails(contractAddress: string, tokenIds: number[]): Promise<NZipTokenDetails[]>;
-    /**
-     * Get contract information (name, symbol, total supply)
-     */
     getContractInfo(contractAddress: string): Promise<{
         name: string;
         symbol: string;
         totalSupply: string;
     } | null>;
-    /**
-     * Check ERC-20 token balances for common tokens
-     */
     checkERC20Tokens(ownerAddress: string, tokenConfigs: CommonTokenConfig[]): Promise<TokenInfo[]>;
-    /**
-     * Check NFT collection balances
-     */
     checkNFTCollections(ownerAddress: string, nftConfigs: CommonTokenConfig[]): Promise<TokenInfo[]>;
-    /**
-     * Detect NZIP contract from deployment file
-     */
     static detectNZipContract(): string | undefined;
-    /**
-     * Get common token configurations for a network
-     */
     static getCommonTokens(network: string): CommonTokenConfig[];
-    /**
-     * Get common NFT configurations for a network
-     */
     static getCommonNFTs(network: string): CommonTokenConfig[];
 }