neozipkit 0.1.1

package/src/server/blockchain/WalletAnalyzer.ts

@@ -0,0 +1,397 @@
+import { ethers } from 'ethers';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Contract ABI for NZIP tokens
+const NZIP_CONTRACT_ABI = [
+  "function getZipFileInfo(uint256 tokenId) view returns (tuple(string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, address creator))",
+  "function ownerOf(uint256 tokenId) view returns (address)",
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function totalSupply() view returns (uint256)",
+  "function getTokensByMerkleRoot(string merkleRootHash) view returns (uint256[])",
+  "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash)"
+];
+
+// ERC-20 token ABI for checking other tokens
+const ERC20_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function decimals() view returns (uint8)"
+];
+
+// ERC-721 NFT ABI
+const ERC721_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)"
+];
+
+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 class WalletAnalyzer {
+  private provider: ethers.JsonRpcProvider;
+
+  constructor(provider: ethers.JsonRpcProvider) {
+    this.provider = provider;
+  }
+
+  /**
+   * Get basic wallet information (balance, transaction count, etc.)
+   */
+  async getWalletBasics(address: string): Promise<WalletBasicInfo> {
+    try {
+      // Get ETH balance
+      const balance = await this.provider.getBalance(address);
+      const ethBalance = ethers.formatEther(balance);
+
+      // Get transaction count (nonce)
+      const txCount = await this.provider.getTransactionCount(address);
+
+      // Get network info
+      const network = await this.provider.getNetwork();
+
+      // Get latest block
+      const latestBlock = await this.provider.getBlockNumber();
+
+      return {
+        ethBalance,
+        transactionCount: txCount,
+        networkName: network.name,
+        chainId: network.chainId,
+        latestBlock
+      };
+    } catch (error) {
+      throw new Error(`Failed to get wallet basics: ${error}`);
+    }
+  }
+
+  /**
+   * Scan for NZIP tokens owned by an address using multiple methods
+   */
+  async scanForNZipTokens(contractAddress: string, ownerAddress: string): Promise<TokenScanResult> {
+    const contract = new ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
+    let foundTokens: number[] = [];
+    let searchMethod: TokenScanResult['searchMethod'] = 'none';
+
+    // Method 1: Try events with recent blocks only
+    try {
+      const latestBlock = await this.provider.getBlockNumber();
+      const startBlock = Math.max(0, latestBlock - 50000);
+      
+      const filter = contract.filters.ZipFileTokenized(null, ownerAddress);
+      const events = await contract.queryFilter(filter, startBlock, 'latest');
+      
+      for (const event of events) {
+        if ('args' in event && event.args && event.args.tokenId) {
+          const tokenId = Number(event.args.tokenId);
+          if (!foundTokens.includes(tokenId)) {
+            foundTokens.push(tokenId);
+          }
+        }
+      }
+      
+      if (foundTokens.length > 0) {
+        searchMethod = 'recent-events';
+        return { foundTokens, searchMethod };
+      }
+    } catch (eventError) {
+      // Continue to next method
+    }
+
+    // Method 2: Direct token ID checking (brute force for small supply)
+    try {
+      const totalSupply = await contract.totalSupply();
+      const maxCheck = Math.min(Number(totalSupply), 50); // Limit to 50 tokens max
+      
+      for (let tokenId = 0; tokenId < maxCheck; tokenId++) {
+        try {
+          const owner = await contract.ownerOf(tokenId);
+          if (owner.toLowerCase() === ownerAddress.toLowerCase()) {
+            foundTokens.push(tokenId);
+          }
+        } catch (ownerError) {
+          // Token doesn't exist or other error, skip
+        }
+      }
+      
+      if (foundTokens.length > 0) {
+        searchMethod = 'iteration';
+        return { foundTokens, searchMethod };
+      }
+    } catch (iterationError) {
+      // Continue to next method
+    }
+
+    // Method 3: Check specific token IDs that commonly exist
+    const commonTokenIds = Array.from({length: 20}, (_, i) => i); // 0-19
+    
+    for (const tokenId of commonTokenIds) {
+      try {
+        const owner = await contract.ownerOf(tokenId);
+        if (owner.toLowerCase() === ownerAddress.toLowerCase()) {
+          foundTokens.push(tokenId);
+        }
+      } catch (ownerError) {
+        // Token doesn't exist, skip
+      }
+    }
+    
+    if (foundTokens.length > 0) {
+      searchMethod = 'common-ids';
+    }
+
+    return { foundTokens, searchMethod };
+  }
+
+  /**
+   * Get detailed information about NZIP tokens
+   */
+  async getNZipTokenDetails(contractAddress: string, tokenIds: number[]): Promise<NZipTokenDetails[]> {
+    const contract = new ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
+    const tokenDetails: NZipTokenDetails[] = [];
+
+    for (const tokenId of tokenIds) {
+      try {
+        const zipInfo = await contract.getZipFileInfo(tokenId);
+        
+        tokenDetails.push({
+          tokenId: tokenId.toString(),
+          merkleRootHash: zipInfo.merkleRootHash,
+          fileName: zipInfo.fileName,
+          timestamp: Number(zipInfo.creationTimestamp),
+          creator: zipInfo.creator,
+          creationTimestamp: Number(zipInfo.creationTimestamp),
+          tokenizationTime: Number(zipInfo.tokenizationTime),
+          ipfsHash: zipInfo.ipfsHash || undefined
+        });
+      } catch (error) {
+        console.error(`Error fetching details for token ${tokenId}:`, error);
+      }
+    }
+
+    return tokenDetails;
+  }
+
+  /**
+   * Get contract information (name, symbol, total supply)
+   */
+  async getContractInfo(contractAddress: string): Promise<{name: string, symbol: string, totalSupply: string} | null> {
+    try {
+      const contract = new ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
+      
+      const [name, symbol, totalSupply] = await Promise.all([
+        contract.name(),
+        contract.symbol(),
+        contract.totalSupply()
+      ]);
+      
+      return {
+        name,
+        symbol,
+        totalSupply: totalSupply.toString()
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Check ERC-20 token balances for common tokens
+   */
+  async checkERC20Tokens(ownerAddress: string, tokenConfigs: CommonTokenConfig[]): Promise<TokenInfo[]> {
+    const foundTokens: TokenInfo[] = [];
+    
+    for (const tokenConfig of tokenConfigs.filter(t => t.type === 'ERC20')) {
+      try {
+        const contract = new ethers.Contract(tokenConfig.address, ERC20_ABI, this.provider);
+        
+        const balance = await contract.balanceOf(ownerAddress);
+        if (balance > 0) {
+          let name, symbol, decimals;
+          
+          try {
+            [name, symbol, decimals] = await Promise.all([
+              contract.name(),
+              contract.symbol(), 
+              contract.decimals()
+            ]);
+          } catch (metadataError) {
+            // Use fallback info if contract calls fail
+            name = tokenConfig.name;
+            symbol = tokenConfig.symbol;
+            decimals = 18; // Default decimals
+          }
+          
+          const formattedBalance = ethers.formatUnits(balance, decimals);
+          
+          foundTokens.push({
+            address: tokenConfig.address,
+            name,
+            symbol,
+            balance: formattedBalance,
+            decimals,
+            type: 'ERC20'
+          });
+        }
+      } catch (error) {
+        // Token might not exist or might not be ERC20, continue silently
+      }
+    }
+
+    return foundTokens;
+  }
+
+  /**
+   * Check NFT collection balances
+   */
+  async checkNFTCollections(ownerAddress: string, nftConfigs: CommonTokenConfig[]): Promise<TokenInfo[]> {
+    const foundNFTs: TokenInfo[] = [];
+    
+    for (const nftConfig of nftConfigs) {
+      try {
+        const contract = new ethers.Contract(nftConfig.address, ERC721_ABI, this.provider);
+        
+        const balance = await contract.balanceOf(ownerAddress);
+        if (balance > 0) {
+          let name, symbol;
+          try {
+            [name, symbol] = await Promise.all([
+              contract.name(),
+              contract.symbol()
+            ]);
+          } catch (metadataError) {
+            name = nftConfig.name;
+            symbol = nftConfig.symbol;
+          }
+          
+          // Try to get token IDs if balance is small
+          let tokenIds: string[] = [];
+          if (Number(balance) <= 5) {
+            try {
+              for (let i = 0; i < Number(balance); i++) {
+                const tokenId = await contract.tokenOfOwnerByIndex(ownerAddress, i);
+                tokenIds.push(tokenId.toString());
+              }
+            } catch (enumError) {
+              // Unable to enumerate, that's okay
+            }
+          }
+          
+          foundNFTs.push({
+            address: nftConfig.address,
+            name,
+            symbol,
+            balance: balance.toString(),
+            type: 'ERC721'
+          });
+        }
+      } catch (error) {
+        // Contract might not exist or might not be ERC-721, continue silently
+      }
+    }
+
+    return foundNFTs;
+  }
+
+  /**
+   * Detect NZIP contract from deployment file
+   */
+  static detectNZipContract(): string | undefined {
+    const deploymentPath = path.join(process.cwd(), 'zipfile-nft-deployment.json');
+    
+    if (fs.existsSync(deploymentPath)) {
+      try {
+        const deploymentInfo = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+        if (deploymentInfo.address) {
+          return deploymentInfo.address;
+        }
+      } catch (error) {
+        // Could not read deployment file
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get common token configurations for a network
+   */
+  static getCommonTokens(network: string): CommonTokenConfig[] {
+    const commonTokens: Record<string, CommonTokenConfig[]> = {
+      'base-sepolia': [
+        { address: '0x036CbD53842c5426634e7929541eC2318f3dCF7e', name: 'USD Coin', symbol: 'USDC', type: 'ERC20' },
+        { address: '0x4200000000000000000000000000000000000006', name: 'Wrapped Ether', symbol: 'WETH', type: 'ERC20' },
+        { address: '0xE4aB69C077896252FAFBD49EFD26B5D171A32410', name: 'Coinbase Wrapped Staked ETH', symbol: 'cbETH', type: 'ERC20' },
+      ],
+      'base': [
+        { address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', name: 'USD Coin', symbol: 'USDC', type: 'ERC20' },
+        { address: '0x4200000000000000000000000000000000000006', name: 'Wrapped Ether', symbol: 'WETH', type: 'ERC20' },
+        { address: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb', name: 'Dai Stablecoin', symbol: 'DAI', type: 'ERC20' },
+        { address: '0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22', name: 'Coinbase Wrapped Staked ETH', symbol: 'cbETH', type: 'ERC20' },
+        { address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA', name: 'USD Base Coin', symbol: 'USDbC', type: 'ERC20' },
+      ]
+    };
+
+    return commonTokens[network] || [];
+  }
+
+  /**
+   * Get common NFT configurations for a network
+   */
+  static getCommonNFTs(network: string): CommonTokenConfig[] {
+    const commonNFTs: Record<string, CommonTokenConfig[]> = {
+      'base-sepolia': [
+        // Add known testnet NFTs here when they become available
+      ],
+      'base': [
+        // Base mainnet NFTs - these are examples, real addresses would be different
+        { address: '0x1234567890123456789012345678901234567890', name: 'Base Punks', symbol: 'BPUNK', type: 'ERC721' },
+        { address: '0x0987654321098765432109876543210987654321', name: 'Base Bears', symbol: 'BBEAR', type: 'ERC721' },
+      ]
+    };
+
+    return commonNFTs[network] || [];
+  }
+} 

package/src/server/blockchain/WalletFormatter.ts

@@ -0,0 +1,206 @@
+import { WalletBasicInfo, NZipTokenDetails, TokenInfo, TokenScanResult } from './WalletAnalyzer';
+
+export class WalletFormatter {
+  /**
+   * Display basic wallet information
+   */
+  static displayWalletBasics(walletInfo: WalletBasicInfo): void {
+    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: {name: string, symbol: string, totalSupply: string} | null, isLegacy: boolean = false): void {
+    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: TokenScanResult): void {
+    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: NZipTokenDetails[], scanResult: TokenScanResult, contractAddress: string): void {
+    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: Intl.DateTimeFormatOptions = {
+          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: TokenInfo[]): void {
+    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: TokenInfo[]): void {
+    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: number, totalScanned: number): void {
+    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: any, contractAddress: string): void {
+    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');
+  }
+}