neozipkit 0.1.1 → 0.2.1

package/dist/server/blockchain/TokenVerifier.js

@@ -1,395 +0,0 @@
-"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/WalletFormatter.d.ts

@@ -1,39 +0,0 @@
-import { WalletBasicInfo, NZipTokenDetails, TokenInfo, TokenScanResult } from './WalletAnalyzer';
-export declare class WalletFormatter {
-    /**
-     * Display basic wallet information
-     */
-    static displayWalletBasics(walletInfo: WalletBasicInfo): void;
-    /**
-     * Display contract information
-     */
-    static displayContractInfo(contractInfo: {
-        name: string;
-        symbol: string;
-        totalSupply: string;
-    } | null, isLegacy?: boolean): void;
-    /**
-     * Display token scan progress
-     */
-    static displayTokenScanProgress(scanResult: TokenScanResult): void;
-    /**
-     * Display detailed NZIP token information
-     */
-    static displayNZipTokenDetails(tokenDetails: NZipTokenDetails[], scanResult: TokenScanResult, contractAddress: string): void;
-    /**
-     * Display ERC-20 token information
-     */
-    static displayERC20Tokens(tokens: TokenInfo[]): void;
-    /**
-     * Display NFT collection information
-     */
-    static displayNFTCollections(nfts: TokenInfo[]): void;
-    /**
-     * Display token scan summary
-     */
-    static displayTokenScanSummary(erc20Count: number, totalScanned: number): void;
-    /**
-     * Display error messages for contract connection issues
-     */
-    static displayContractError(error: any, contractAddress: string): void;
-}

package/dist/server/blockchain/WalletFormatter.js

@@ -1,196 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletFormatter = void 0;
-class WalletFormatter {
-    /**
-     * Display basic wallet information
-     */
-    static displayWalletBasics(walletInfo) {
-        console.log('\n💰 Basic Wallet Information');
-        console.log('─'.repeat(50));
-        console.log(`ETH Balance:                                    ${walletInfo.ethBalance} ETH`);
-        console.log(`Transaction Count:                              ${walletInfo.transactionCount}`);
-        console.log(`Network Name:                                   ${walletInfo.networkName}`);
-        console.log(`Chain ID:                                       ${walletInfo.chainId}`);
-        console.log(`Latest Block:                                   ${walletInfo.latestBlock}`);
-    }
-    /**
-     * Display contract information
-     */
-    static displayContractInfo(contractInfo, isLegacy = false) {
-        if (contractInfo) {
-            console.log(`Contract Name:                                  ${contractInfo.name}`);
-            console.log(`Contract Symbol:                                ${contractInfo.symbol}`);
-            console.log(`Total Supply:                                   ${contractInfo.totalSupply}`);
-        }
-        else {
-            console.log('Contract Info:                                  Unable to fetch');
-        }
-    }
-    /**
-     * Display token scan progress
-     */
-    static displayTokenScanProgress(scanResult) {
-        console.log('Searching for tokens owned by this address...');
-        if (scanResult.searchMethod === 'recent-events') {
-            console.log('   🔍 Trying recent events (last 50k blocks)...');
-            console.log(`   ✅ Found ${scanResult.foundTokens.length} tokens from recent events`);
-        }
-        else if (scanResult.searchMethod === 'iteration') {
-            console.log('   🔍 Trying recent events (last 50k blocks)...');
-            console.log('   ❌ Recent events failed, trying alternative methods...');
-            console.log('   🔍 Checking token ownership by iteration...');
-            console.log(`   ✅ Found ${scanResult.foundTokens.length} tokens by iteration`);
-        }
-        else if (scanResult.searchMethod === 'common-ids') {
-            console.log('   🔍 Trying recent events (last 50k blocks)...');
-            console.log('   ❌ Recent events failed, trying alternative methods...');
-            console.log('   🔍 Checking token ownership by iteration...');
-            console.log('   ⚠️  No tokens found by iteration, checking common IDs...');
-            console.log('   🔍 Checking common token IDs (0-19)...');
-            console.log(`   ✅ Found ${scanResult.foundTokens.length} tokens from common IDs`);
-        }
-        else {
-            console.log('   🔍 Trying recent events (last 50k blocks)...');
-            console.log('   ❌ Recent events failed, trying alternative methods...');
-            console.log('   🔍 Checking token ownership by iteration...');
-            console.log('   ⚠️  No tokens found by iteration, checking common IDs...');
-            console.log('   🔍 Checking common token IDs (0-19)...');
-        }
-    }
-    /**
-     * Display detailed NZIP token information
-     */
-    static displayNZipTokenDetails(tokenDetails, scanResult, contractAddress) {
-        if (tokenDetails.length > 0) {
-            console.log(`\n✅ Found ${tokenDetails.length} NZIP token(s) using ${scanResult.searchMethod}:`);
-            console.log('📋 Your NZIP Token Details:');
-            console.log('═'.repeat(80));
-            for (const token of tokenDetails.sort((a, b) => parseInt(a.tokenId) - parseInt(b.tokenId))) {
-                console.log(`\n🎯 Token ID ${token.tokenId}:`);
-                console.log(`   File Name:                                   ${token.fileName}`);
-                console.log(`   Merkle Root:                                 ${token.merkleRootHash}`);
-                // Convert timestamps to dates
-                const creationDate = new Date(token.creationTimestamp * 1000);
-                const tokenizationDate = new Date(token.tokenizationTime * 1000);
-                // Format dates in a more readable format
-                const formatOptions = {
-                    year: 'numeric',
-                    month: 'short',
-                    day: '2-digit',
-                    hour: '2-digit',
-                    minute: '2-digit',
-                    second: '2-digit',
-                    timeZoneName: 'short'
-                };
-                console.log(`   Created:                                     ${creationDate.toLocaleDateString('en-US', formatOptions)}`);
-                console.log(`   Tokenized:                                   ${tokenizationDate.toLocaleDateString('en-US', formatOptions)}`);
-                // Show time difference between creation and tokenization
-                const timeDiffSeconds = token.tokenizationTime - token.creationTimestamp;
-                if (timeDiffSeconds > 0) {
-                    if (timeDiffSeconds < 60) {
-                        console.log(`   Tokenization Delay:                          ${timeDiffSeconds} seconds`);
-                    }
-                    else if (timeDiffSeconds < 3600) {
-                        console.log(`   Tokenization Delay:                          ${Math.round(timeDiffSeconds / 60)} minutes`);
-                    }
-                    else {
-                        console.log(`   Tokenization Delay:                          ${Math.round(timeDiffSeconds / 3600)} hours`);
-                    }
-                }
-                if (token.ipfsHash && token.ipfsHash !== '') {
-                    console.log(`   IPFS Hash:                                   ${token.ipfsHash}`);
-                }
-                console.log(`   Creator:                                     ${token.creator}`);
-                // Calculate age since creation (using current time)
-                const now = Date.now();
-                const ageMs = now - (token.creationTimestamp * 1000);
-                const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
-                const ageHours = Math.floor((ageMs % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
-                const ageMinutes = Math.floor((ageMs % (1000 * 60 * 60)) / (1000 * 60));
-                if (ageDays > 0) {
-                    console.log(`   Age:                                         ${ageDays} days, ${ageHours} hours`);
-                }
-                else if (ageHours > 0) {
-                    console.log(`   Age:                                         ${ageHours} hours, ${ageMinutes} minutes`);
-                }
-                else {
-                    console.log(`   Age:                                         ${ageMinutes} minutes`);
-                }
-            }
-        }
-        else {
-            console.log('\n❌ No NZIP tokens found for this address');
-            console.log('\n💡 This could mean:');
-            console.log('   • You don\'t own any NZIP tokens on this network');
-            console.log('   • The tokens are on a different contract or network');
-            console.log('   • There are temporary RPC connectivity issues');
-            console.log('\n🔧 Try these troubleshooting steps:');
-            console.log('   • Verify you\'re on the correct network (--network flag)');
-            console.log('   • Check if you have tokens on a different contract (--contract flag)');
-            console.log('   • Try again in a few minutes if RPC is experiencing issues');
-            console.log(`   • Verify the contract address: ${contractAddress}`);
-        }
-    }
-    /**
-     * Display ERC-20 token information
-     */
-    static displayERC20Tokens(tokens) {
-        if (tokens.length > 0) {
-            console.log(`\n💰 ERC-20 Token Balances:`);
-            for (const token of tokens) {
-                console.log(`\n   💎 ${token.symbol} (${token.name}):`);
-                console.log(`      Contract:                                 ${token.address}`);
-                console.log(`      Balance:                                  ${token.balance} ${token.symbol}`);
-                console.log(`      Decimals:                                 ${token.decimals}`);
-                // Add USD value estimation for major stablecoins
-                if (['USDC', 'USDT', 'DAI', 'USDbC'].includes(token.symbol)) {
-                    console.log(`      Est. USD Value:                           ~$${token.balance}`);
-                }
-            }
-        }
-    }
-    /**
-     * Display NFT collection information
-     */
-    static displayNFTCollections(nfts) {
-        console.log(`\n🖼️  Other NFT Collections:`);
-        if (nfts.length > 0) {
-            for (const nft of nfts) {
-                console.log(`\n   🖼️  ${nft.symbol} (${nft.name}):`);
-                console.log(`      Contract:                                 ${nft.address}`);
-                console.log(`      NFTs Owned:                               ${nft.balance}`);
-            }
-        }
-        else {
-            console.log(`   No other NFT collections found`);
-        }
-    }
-    /**
-     * Display token scan summary
-     */
-    static displayTokenScanSummary(erc20Count, totalScanned) {
-        console.log(`\n📊 Token Scan Summary:`);
-        console.log(`   ERC-20 Tokens Found:                          ${erc20Count}`);
-        console.log(`   Total Tokens Scanned:                         ${totalScanned}`);
-        if (erc20Count === 0) {
-            console.log(`\n💡 No tokens found. This could mean:`);
-            console.log(`   • This is a new wallet with no token activity`);
-            console.log(`   • Tokens are on a different network`);
-            console.log(`   • You have tokens not in our common token list`);
-            console.log(`   • There are temporary RPC connectivity issues`);
-        }
-    }
-    /**
-     * Display error messages for contract connection issues
-     */
-    static displayContractError(error, contractAddress) {
-        console.error('❌ Error connecting to NZIP contract:', error);
-        console.log('\n🔧 Troubleshooting suggestions:');
-        console.log('   • Check if the contract address is correct');
-        console.log('   • Verify you\'re on the right network');
-        console.log('   • Try again later if RPC is experiencing issues');
-        console.log('   • Use --contract flag to specify a different contract address');
-    }
-}
-exports.WalletFormatter = WalletFormatter;

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

@@ -1,46 +0,0 @@
-import { ethers } from 'ethers';
-import { WalletSetupResult, MintingOptions } from './types';
-export declare class WalletManager {
-    private wallet;
-    private provider;
-    /**
-     * Prompts the user for input
-     */
-    private promptUser;
-    /**
-     * Looks for existing wallet files in the current directory and wallet subdirectory
-     */
-    private findExistingWallets;
-    /**
-     * Loads wallet information from a file
-     */
-    private loadWalletFromFile;
-    /**
-     * Sets up a Base wallet for token operations
-     */
-    setupWallet(options: MintingOptions): Promise<WalletSetupResult>;
-    /**
-     * Creates a new wallet and saves it to file
-     */
-    private createNewWallet;
-    /**
-     * Connects to the specified blockchain network
-     */
-    private connectToNetwork;
-    /**
-     * Gets the current wallet instance
-     */
-    getWallet(): ethers.Wallet | null;
-    /**
-     * Gets the current provider instance
-     */
-    getProvider(): ethers.JsonRpcProvider | null;
-    /**
-     * Checks if wallet is connected and ready for transactions
-     */
-    isReady(): boolean;
-    /**
-     * Checks if provider is connected
-     */
-    isOnline(): boolean;
-}