neozipkit 0.2.1 → 0.3.0

package/src/blockchain/{ZipKitWallet.ts → core/WalletManager.ts}

@@ -1,23 +1,60 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as readline from 'readline';
+/**
+ * Core WalletManager - Platform-agnostic wallet functionality
+ * Provides core wallet operations that work in both browser and server environments
+ */
+
 import { ethers } from 'ethers';
-import { WalletSetupResult, WalletInfo, NetworkConfig, NETWORKS, MintingOptions } from './types';
+import { WalletSetupResult, WalletInfo, NetworkConfig, NETWORKS, MintingOptions } from '../../types';
+import { Logger } from '../../core/components/Logger';
+
+export interface CommonTokenConfig { 
+  address: string; 
+  name: string; 
+  symbol: string; 
+  type: 'ERC20' | 'ERC721'; 
+}
+
+export interface TokenInfo { 
+  address: string; 
+  name: string; 
+  symbol: string; 
+  balance: string; 
+  decimals?: number; 
+  type: 'ERC20' | 'ERC721' | 'NZIP'; 
+}
+
+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 interface TokenInfo { address: string; name: string; symbol: string; balance: string; decimals?: number; type: 'ERC20' | 'ERC721' | 'NZIP'; }
-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 NZipTokenDetails { tokenId: string; merkleRootHash: string; fileName: string; timestamp: number; tokenURI?: string; creator: string; creationTimestamp: number; tokenizationTime: number; ipfsHash?: string; }
+export interface NZipTokenDetails { 
+  tokenId: string; 
+  merkleRootHash: string; 
+  timestamp: number; 
+  tokenURI?: string; 
+  creator: string; 
+  creationTimestamp: number; 
+  tokenizationTime: number; 
+  ipfsHash?: string; 
+}
 
 const NZIP_CONTRACT_ABI = [
-  "function getZipFileInfo(uint256 tokenId) view returns (tuple(string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, address creator))",
+  "function getZipFileInfo(uint256 tokenId) view returns (tuple(string merkleRootHash, string ipfsHash, address creator, uint256 creationTimestamp, uint256 tokenizationTime, uint256 blockNumber))",
   "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)"
+  "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
 ];
 
 const ERC20_ABI = [
@@ -34,195 +71,208 @@ const ERC721_ABI = [
   "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)"
 ];
 
-export class ZipKitWallet {
-  private wallet: ethers.Wallet | null = null;
-  private provider: ethers.JsonRpcProvider | null = null;
-
-  private async promptUser(question: string): Promise<string> {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise<string>((resolve) => {
-      rl.question(question, (answer: string) => { rl.close(); resolve(answer.trim()); });
-    });
-  }
-
-  private findExistingWallets(): string[] {
-    const walletFiles: string[] = [];
-    const currentDir = process.cwd();
-    const walletDir = path.join(currentDir, 'wallet');
-    const walletFileNames = ['neozip-wallet.json'];
-    for (const fileName of walletFileNames) {
-      const filePath = path.join(currentDir, fileName);
-      if (fs.existsSync(filePath)) walletFiles.push(filePath);
-    }
-    if (fs.existsSync(walletDir)) {
-      for (const fileName of walletFileNames) {
-        const filePath = path.join(walletDir, fileName);
-        if (fs.existsSync(filePath)) walletFiles.push(filePath);
-      }
-    }
-    return walletFiles;
-  }
+/**
+ * Core wallet functionality that works in both browser and server environments
+ */
+export class CoreWalletManager {
+  protected wallet: ethers.Wallet | null = null;
+  protected provider: ethers.JsonRpcProvider | null = null;
 
-  private loadWalletFromFile(filePath: string): string | null {
-    try {
-      const content = fs.readFileSync(filePath, 'utf8').trim();
-      try {
-        const walletData = JSON.parse(content);
-        if (walletData.privateKey) {
-          console.log(`Found wallet file: ${filePath}`);
-          console.log(`Wallet address: ${walletData.address}`);
-          return walletData.privateKey;
-        }
-      } catch {
-        if (content.startsWith('0x') && content.length === 66) {
-          console.log(`Found private key file: ${filePath}`);
-          return content;
-        }
-      }
-      return null;
-    } catch (error) {
-      console.warn(`Could not read wallet file ${filePath}:`, error);
-      return null;
-    }
-  }
+  constructor() {}
 
-  async setupWallet(options: MintingOptions): Promise<WalletSetupResult> {
+  /**
+   * Setup wallet with private key and connect to network
+   * 
+   * SECURITY WARNING: This method accepts a private key as a parameter.
+   * - Never hardcode private keys in source code
+   * - Always use environment variables for private keys
+   * - Use testnet keys for development/testing
+   * - Use secure key management (HSMs, KMS) for production
+   * - See SECURITY.md for complete security guidelines
+   */
+  async setupWallet(privateKey: string, network: string, mintToken: boolean = false): Promise<WalletSetupResult> {
     try {
-      const networkConfig = NETWORKS[options.network] || NETWORKS['base-sepolia'];
-      let privateKey: string;
-      if ((options as any).wallet) {
-        const val = (options as any).wallet as string;
-        if (fs.existsSync(val)) {
-          const loaded = this.loadWalletFromFile(val);
-          if (!loaded) throw new Error(`Could not load valid private key from ${val}`);
-          privateKey = loaded;
-        } else {
-          privateKey = val;
-        }
-      } else {
-        const existing = this.findExistingWallets();
-        if (existing.length > 0) {
-          const selected = existing[0];
-          const relativePath = path.relative(process.cwd(), selected);
-          console.log(`Using existing wallet: ${relativePath}`);
-          const loaded = this.loadWalletFromFile(selected);
-          if (!loaded) throw new Error(`Could not load valid private key from ${selected}`);
-          privateKey = loaded;
-        } else {
-          console.log('No existing wallet found. Creating new wallet...');
-          privateKey = await this.createNewWallet();
-        }
-      }
-
+      const networkConfig = NETWORKS[network] || NETWORKS['base-sepolia'];
+      
       this.wallet = new ethers.Wallet(privateKey);
-      console.log(`Using wallet: ${this.wallet.address}`);
-      const ok = await this.connectToNetwork(networkConfig, (options as any).mintToken === true);
+      Logger.log(`Using wallet: ${this.wallet.address}`);
+      
+      const ok = await this.connectToNetwork(networkConfig, mintToken);
       if (!ok) {
-        return { wallet: null, provider: null, success: false, message: `Failed to connect to ${networkConfig.name} network. Blockchain operations require network connectivity.` };
+        return { 
+          wallet: null, 
+          provider: null, 
+          success: false, 
+          message: `Failed to connect to ${networkConfig.name} network. Blockchain operations require network connectivity.` 
+        };
       }
-      return { wallet: this.wallet, provider: this.provider, success: true, message: `Wallet setup successful for ${networkConfig.name}` };
+      
+      return { 
+        wallet: this.wallet, 
+        provider: this.provider, 
+        success: true, 
+        message: `Wallet setup successful for ${networkConfig.name}` 
+      };
     } catch (error) {
-      console.error('Error setting up wallet:', error);
-      return { wallet: null, provider: null, success: false, message: `Wallet setup failed: ${error instanceof Error ? error.message : String(error)}` };
+      Logger.error('Error setting up wallet:', error);
+      return { 
+        wallet: null, 
+        provider: null, 
+        success: false, 
+        message: `Wallet setup failed: ${error instanceof Error ? error.message : String(error)}` 
+      };
     }
   }
 
-  private async createNewWallet(): Promise<string> {
-    console.log('Creating a new wallet...');
-    const newWallet = ethers.Wallet.createRandom();
-    const walletInfo: WalletInfo = { address: newWallet.address, privateKey: newWallet.privateKey, mnemonic: newWallet.mnemonic?.phrase || "" };
-    const walletDir = path.join(process.cwd(), 'wallet');
-    if (!fs.existsSync(walletDir)) fs.mkdirSync(walletDir, { recursive: true });
-    const walletFilePath = path.join(walletDir, 'neozip-wallet.json');
-    fs.writeFileSync(walletFilePath, JSON.stringify(walletInfo, null, 2));
-    console.log(`New wallet created and saved to ${walletFilePath}`);
-    console.log(`Wallet address: ${newWallet.address}`);
-    console.log(`IMPORTANT: Please fund this wallet with BASE to use for minting NFTs!`);
-    return newWallet.privateKey;
-  }
-
-  private async connectToNetwork(networkConfig: NetworkConfig, mintToken: boolean): Promise<boolean> {
+  /**
+   * Connect to the specified network
+   */
+  protected async connectToNetwork(networkConfig: NetworkConfig, mintToken: boolean): Promise<boolean> {
     try {
-      console.log(`Attempting to connect to ${networkConfig.name} network...`);
+      Logger.log(`Attempting to connect to ${networkConfig.name} network...`);
       this.provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+      
       let networkTimedOut = false;
-      const networkTimeout = setTimeout(() => { networkTimedOut = true; console.error("Network connection timeout"); }, 5000);
+      const networkTimeout = setTimeout(() => { 
+        networkTimedOut = true; 
+        Logger.error("Network connection timeout"); 
+      }, 5000);
+      
       await Promise.race([
         this.provider.getNetwork(),
-        new Promise((_, reject) => setTimeout(() => { if (networkTimedOut) reject(new Error("Network connection timeout")); }, 5100))
+        new Promise((_, reject) => 
+          setTimeout(() => { 
+            if (networkTimedOut) reject(new Error("Network connection timeout")); 
+          }, 5100)
+        )
       ]);
+      
       clearTimeout(networkTimeout);
+      
       if (this.wallet) {
         this.wallet = this.wallet.connect(this.provider);
         const balance = await this.provider.getBalance(this.wallet.address);
         const balanceEth = ethers.formatEther(balance);
-        console.log(`Wallet balance: ${balanceEth} ETH`);
+        Logger.log(`Wallet balance: ${balanceEth} ETH`);
+        
         const minBalance = 0.0001;
         if (parseFloat(balanceEth) < minBalance && mintToken) {
-          console.error(`ERROR: Insufficient balance (${balanceEth} ETH). Minimum required: ${minBalance} ETH`);
-          console.error('Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+          Logger.error(`ERROR: Insufficient balance (${balanceEth} ETH). Minimum required: ${minBalance} ETH`);
+          Logger.error('Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
           throw new Error(`Insufficient balance for minting. Current: ${balanceEth} ETH, Required: ${minBalance} ETH`);
         } else if (mintToken) {
-          console.log(`✅ Sufficient balance for token minting`);
+          Logger.log(`✅ Sufficient balance for token minting`);
         }
       }
-      console.log(`✅ Successfully connected to ${networkConfig.name}`);
+      
+      Logger.log(`✅ Successfully connected to ${networkConfig.name}`);
       return true;
     } catch (networkError: unknown) {
       const errorMessage = networkError instanceof Error ? networkError.message : String(networkError);
-      console.error(`Failed to connect to ${networkConfig.name} network: ${errorMessage}`);
+      Logger.error(`Failed to connect to ${networkConfig.name} network: ${errorMessage}`);
       this.provider = null;
       return false;
     }
   }
 
-  getWallet(): ethers.Wallet | null { return this.wallet; }
-  getProvider(): ethers.JsonRpcProvider | null { return this.provider; }
-  isReady(): boolean { return this.wallet !== null; }
-  isOnline(): boolean { return this.provider !== null; }
+  /**
+   * Get the current wallet instance
+   */
+  getWallet(): ethers.Wallet | null { 
+    return this.wallet; 
+  }
+
+  /**
+   * Get the current provider instance
+   */
+  getProvider(): ethers.JsonRpcProvider | null { 
+    return this.provider; 
+  }
+
+  /**
+   * Check if wallet is ready
+   */
+  isReady(): boolean { 
+    return this.wallet !== null; 
+  }
+
+  /**
+   * Check if connected to network
+   */
+  isOnline(): boolean { 
+    return this.provider !== null; 
+  }
 }
 
+/**
+ * Wallet analyzer for blockchain operations
+ */
 export class WalletAnalyzer {
   private provider: ethers.JsonRpcProvider;
-  constructor(provider: ethers.JsonRpcProvider) { this.provider = provider; }
+  
+  constructor(provider: ethers.JsonRpcProvider) { 
+    this.provider = provider; 
+  }
 
+  /**
+   * Get basic wallet information
+   */
   async getWalletBasics(address: string): Promise<WalletBasicInfo> {
     const balance = await this.provider.getBalance(address);
     const ethBalance = ethers.formatEther(balance);
     const txCount = await this.provider.getTransactionCount(address);
     const network = await this.provider.getNetwork();
     const latestBlock = await this.provider.getBlockNumber();
-    return { ethBalance, transactionCount: txCount, networkName: network.name, chainId: network.chainId, latestBlock };
+    
+    return { 
+      ethBalance, 
+      transactionCount: txCount, 
+      networkName: network.name, 
+      chainId: network.chainId, 
+      latestBlock 
+    };
   }
 
+  /**
+   * Scan for NZIP tokens owned by an address
+   */
   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';
+    
     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 as any).args.tokenId) {
           const tokenId = Number((event as any).args.tokenId);
           if (!foundTokens.includes(tokenId)) foundTokens.push(tokenId);
         }
       }
-      if (foundTokens.length > 0) { return { foundTokens, searchMethod: 'recent-events' }; }
+      
+      if (foundTokens.length > 0) { 
+        return { foundTokens, searchMethod: 'recent-events' }; 
+      }
     } catch {}
+    
     try {
       const totalSupply = await contract.totalSupply();
       const maxCheck = Math.min(Number(totalSupply), 50);
+      
       for (let tokenId = 0; tokenId < maxCheck; tokenId++) {
         try {
           const owner = await contract.ownerOf(tokenId);
           if (owner.toLowerCase() === ownerAddress.toLowerCase()) foundTokens.push(tokenId);
         } catch {}
       }
+      
       if (foundTokens.length > 0) return { foundTokens, searchMethod: 'iteration' };
     } catch {}
+    
     const commonTokenIds = Array.from({length: 20}, (_, i) => i);
     for (const tokenId of commonTokenIds) {
       try {
@@ -230,19 +280,23 @@ export class WalletAnalyzer {
         if (owner.toLowerCase() === ownerAddress.toLowerCase()) foundTokens.push(tokenId);
       } catch {}
     }
+    
     return { foundTokens, searchMethod: foundTokens.length > 0 ? 'common-ids' : 'none' };
   }
 
+  /**
+   * Get detailed information for 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),
@@ -250,61 +304,104 @@ export class WalletAnalyzer {
           ipfsHash: zipInfo.ipfsHash || undefined
         });
       } catch (error) {
-        console.error(`Error fetching details for token ${tokenId}:`, error);
+        Logger.error(`Error fetching details for token ${tokenId}:`, error);
       }
     }
+    
     return tokenDetails;
   }
 
+  /**
+   * Get contract information
+   */
   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()]);
+      const [name, symbol, totalSupply] = await Promise.all([
+        contract.name(), 
+        contract.symbol(), 
+        contract.totalSupply()
+      ]);
       return { name, symbol, totalSupply: totalSupply.toString() };
-    } catch { return null; }
+    } catch { 
+      return null; 
+    }
   }
 
+  /**
+   * Check for ERC20 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 = tokenConfig.name, symbol = tokenConfig.symbol, decimals = 18;
-          try { [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]); } catch {}
+          try { 
+            [name, symbol, decimals] = await Promise.all([
+              contract.name(), 
+              contract.symbol(), 
+              contract.decimals()
+            ]); 
+          } catch {}
+          
           const formattedBalance = ethers.formatUnits(balance, decimals);
-          foundTokens.push({ address: tokenConfig.address, name, symbol, balance: formattedBalance, decimals, type: 'ERC20' });
+          foundTokens.push({ 
+            address: tokenConfig.address, 
+            name, 
+            symbol, 
+            balance: formattedBalance, 
+            decimals, 
+            type: 'ERC20' 
+          });
         }
       } catch {}
     }
+    
     return foundTokens;
   }
 
+  /**
+   * Check for NFT collections
+   */
   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 = nftConfig.name, symbol = nftConfig.symbol;
-          try { [name, symbol] = await Promise.all([contract.name(), contract.symbol()]); } catch {}
-          foundNFTs.push({ address: nftConfig.address, name, symbol, balance: balance.toString(), type: 'ERC721' });
+          try { 
+            [name, symbol] = await Promise.all([
+              contract.name(), 
+              contract.symbol()
+            ]); 
+          } catch {}
+          
+          foundNFTs.push({ 
+            address: nftConfig.address, 
+            name, 
+            symbol, 
+            balance: balance.toString(), 
+            type: 'ERC721' 
+          });
         }
       } catch {}
     }
+    
     return foundNFTs;
   }
 
-  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 {}
-    }
-    return undefined;
-  }
-
+  /**
+   * Get common token configurations for a network
+   */
   static getCommonTokens(network: string): CommonTokenConfig[] {
     const commonTokens: Record<string, CommonTokenConfig[]> = {
       'base-sepolia': [
@@ -323,6 +420,9 @@ export class WalletAnalyzer {
     return commonTokens[network] || [];
   }
 
+  /**
+   * Get common NFT configurations for a network
+   */
   static getCommonNFTs(network: string): CommonTokenConfig[] {
     const commonNFTs: Record<string, CommonTokenConfig[]> = {
       'base-sepolia': [ ],
@@ -334,5 +434,3 @@ export class WalletAnalyzer {
     return commonNFTs[network] || [];
   }
 }
-
-