neozipkit 0.1.1

package/dist/server/blockchain/TokenVerifier.js

@@ -0,0 +1,395 @@
+"use strict";
+// ======================================
+//	TokenVerifier.ts
+//  Blockchain token verification utilities for ZIP archives
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForTokenization = checkForTokenization;
+const Headers_1 = require("../../shared/constants/Headers");
+const ZipMetadata_1 = require("./ZipMetadata");
+const CertificateToken_1 = require("./CertificateToken");
+// Network configuration for blockchain queries
+const NETWORK_CONFIG = {
+    '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'
+        ]
+    }
+};
+/**
+ * Checks if the ZIP file contains NFT token metadata and verifies the merkle root
+ */
+async function checkForTokenization(zipKit, options = {}) {
+    const zipEntries = zipKit.getDirectory();
+    // Look for the tokenized metadata file
+    const tokenEntry = zipEntries.find(entry => entry.filename === Headers_1.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_1.ZipMetadata.validateTokenInfo(tokenMetadata) && tokenMetadata) {
+                    console.log('✅ Valid NFT token metadata found');
+                    // Display token information
+                    console.log(ZipMetadata_1.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;
+                                    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;
+                                    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;
+                                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) {
+    try {
+        const { ethers } = await Promise.resolve().then(() => __importStar(require('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) {
+    try {
+        // Get all entries except the token file
+        const zipEntries = zipKit.getDirectory();
+        const contentEntries = zipEntries.filter(entry => entry.filename !== Headers_1.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, zipFileName, zipEntries, blockchainVerification) {
+    console.log('\n📜 Generating Token Certificate...');
+    try {
+        // Prepare token information
+        const tokenInfo = {
+            tokenId: tokenMetadata.tokenId,
+            contractAddress: tokenMetadata.contractAddress,
+            network: tokenMetadata.network,
+            transactionHash: tokenMetadata.transactionHash
+        };
+        // Prepare file information from ZIP entries
+        const zipFiles = [];
+        for (const entry of zipEntries) {
+            // Skip the token file itself and directories
+            if (entry.filename !== Headers_1.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 = (0, CertificateToken_1.createTokenCertificate)(tokenInfo, zipFileName, blockchainVerification, undefined, // walletInfo
+        zipFiles);
+        // Save the certificate
+        const certPath = (0, CertificateToken_1.saveCertificate)(zipFileName, certificateHTML);
+        console.log(`✅ Certificate generated: ${certPath}`);
+        return certPath;
+    }
+    catch (error) {
+        console.error('❌ Failed to generate certificate:', error);
+        throw error;
+    }
+}

package/dist/server/blockchain/WalletAnalyzer.d.ts

@@ -0,0 +1,81 @@
+import { ethers } from 'ethers';
+export interface TokenInfo {
+    address: string;
+    name: string;
+    symbol: string;
+    balance: string;
+    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;
+    networkName: string;
+    chainId: bigint;
+    latestBlock: number;
+}
+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 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[];
+}