neozipkit 0.1.1

package/src/server/blockchain/WalletManager.ts

@@ -0,0 +1,294 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { ethers } from 'ethers';
+import { 
+  WalletSetupResult, 
+  WalletInfo, 
+  NetworkConfig, 
+  NETWORKS,
+  MintingOptions 
+} from './types';
+
+export class WalletManager {
+  private wallet: ethers.Wallet | null = null;
+  private provider: ethers.JsonRpcProvider | null = null;
+
+  /**
+   * Prompts the user for input
+   */
+  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());
+      });
+    });
+  }
+
+  /**
+   * Looks for existing wallet files in the current directory and wallet subdirectory
+   */
+  private findExistingWallets(): string[] {
+    const walletFiles: string[] = [];
+    const currentDir = process.cwd();
+    const walletDir = path.join(currentDir, 'wallet');
+    
+    // Common wallet file names to look for
+    const walletFileNames = [
+      'neozip-wallet.json',
+      'wallet.json',
+      'private-key.txt',
+      'private.key'
+    ];
+
+    // Search in current directory
+    for (const fileName of walletFileNames) {
+      const filePath = path.join(currentDir, fileName);
+      if (fs.existsSync(filePath)) {
+        walletFiles.push(filePath);
+      }
+    }
+
+    // Search in wallet subdirectory
+    if (fs.existsSync(walletDir)) {
+      for (const fileName of walletFileNames) {
+        const filePath = path.join(walletDir, fileName);
+        if (fs.existsSync(filePath)) {
+          walletFiles.push(filePath);
+        }
+      }
+    }
+
+    return walletFiles;
+  }
+
+  /**
+   * Loads wallet information from a file
+   */
+  private loadWalletFromFile(filePath: string): string | null {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8').trim();
+      
+      // Try to parse as JSON first (for neozip-wallet.json format)
+      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 not JSON, treat as plain private key
+        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;
+    }
+  }
+
+  /**
+   * Sets up a Base wallet for token operations
+   */
+  async setupWallet(options: MintingOptions): Promise<WalletSetupResult> {
+    try {
+      const networkConfig = NETWORKS[options.network] || NETWORKS['base-sepolia'];
+      
+      let privateKey: string;
+      
+      // Check if wallet is explicitly provided via command line
+      if (options.wallet) {
+        if (fs.existsSync(options.wallet)) {
+          // Read wallet from specified file
+          const loadedKey = this.loadWalletFromFile(options.wallet);
+          if (!loadedKey) {
+            throw new Error(`Could not load valid private key from ${options.wallet}`);
+          }
+          privateKey = loadedKey;
+        } else {
+          // Use directly provided private key or mnemonic
+          privateKey = options.wallet;
+        }
+      } else {
+        // Look for existing wallet files
+        const existingWallets = this.findExistingWallets();
+        
+        if (existingWallets.length > 0) {
+          // Automatically use the first available wallet
+          const selectedWallet = existingWallets[0];
+          const relativePath = path.relative(process.cwd(), selectedWallet);
+          console.log(`Using existing wallet: ${relativePath}`);
+          
+          const loadedKey = this.loadWalletFromFile(selectedWallet);
+          if (!loadedKey) {
+            throw new Error(`Could not load valid private key from ${selectedWallet}`);
+          }
+          privateKey = loadedKey;
+        } else {
+          // Automatically create new wallet
+          console.log('No existing wallet found. Creating new wallet...');
+          privateKey = await this.createNewWallet();
+        }
+      }
+      
+      // Create wallet instance without provider first
+      this.wallet = new ethers.Wallet(privateKey);
+      console.log(`Using wallet: ${this.wallet.address}`);
+      
+      // Try to connect to the network - FAIL if connection fails
+      const networkConnected = await this.connectToNetwork(networkConfig, options.mintToken);
+      
+      if (!networkConnected) {
+        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}`
+      };
+      
+    } 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)}`
+      };
+    }
+  }
+
+  /**
+   * Creates a new wallet and saves it to file
+   */
+  private async createNewWallet(): Promise<string> {
+    console.log('Creating a new wallet...');
+    const newWallet = ethers.Wallet.createRandom();
+    
+    // Save the wallet info
+    const walletInfo: WalletInfo = {
+      address: newWallet.address,
+      privateKey: newWallet.privateKey,
+      mnemonic: newWallet.mnemonic?.phrase || ""
+    };
+    
+    // Ensure wallet directory exists
+    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;
+  }
+
+  /**
+   * Connects to the specified blockchain network
+   */
+  private async connectToNetwork(networkConfig: NetworkConfig, mintToken: boolean): Promise<boolean> {
+    try {
+      console.log(`Attempting to connect to ${networkConfig.name} network...`);
+      this.provider = new ethers.JsonRpcProvider(networkConfig.rpcUrl);
+      
+      // Set a timeout for network connection
+      let networkTimedOut = false;
+      const networkTimeout = setTimeout(() => {
+        networkTimedOut = true;
+        console.error("Network connection timeout");
+      }, 5000);
+      
+      // Test the connection
+      const network = await Promise.race([
+        this.provider.getNetwork(),
+        new Promise((_, reject) => 
+          setTimeout(() => {
+            if (networkTimedOut) reject(new Error("Network connection timeout"));
+          }, 5100)
+        )
+      ]);
+      
+      clearTimeout(networkTimeout);
+      
+      // Connect wallet to provider
+      if (this.wallet) {
+        this.wallet = this.wallet.connect(this.provider);
+        
+        // Check wallet balance
+        const balance = await this.provider.getBalance(this.wallet.address);
+        const balanceEth = ethers.formatEther(balance);
+        console.log(`Wallet balance: ${balanceEth} ETH`);
+        
+        // Check if balance is sufficient for minting
+        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');
+          throw new Error(`Insufficient balance for minting. Current: ${balanceEth} ETH, Required: ${minBalance} ETH`);
+        } else if (mintToken) {
+          console.log(`✅ Sufficient balance for token minting`);
+        }
+      }
+      
+      console.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}`);
+      this.provider = null;
+      return false;
+    }
+  }
+
+  /**
+   * Gets the current wallet instance
+   */
+  getWallet(): ethers.Wallet | null {
+    return this.wallet;
+  }
+
+  /**
+   * Gets the current provider instance
+   */
+  getProvider(): ethers.JsonRpcProvider | null {
+    return this.provider;
+  }
+
+  /**
+   * Checks if wallet is connected and ready for transactions
+   */
+  isReady(): boolean {
+    return this.wallet !== null;
+  }
+
+  /**
+   * Checks if provider is connected
+   */
+  isOnline(): boolean {
+    return this.provider !== null;
+  }
+} 

package/src/server/blockchain/ZipMetadata.ts

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { NZipTokenInfo, ContractInfo, NETWORKS } from './types';
+
+export class ZipMetadata {
+  /**
+   * Creates the META-INF/NZIP.TOKEN content
+   */
+  static createTokenInfo(
+    tokenId: string,
+    transactionHash: string,
+    contractInfo: ContractInfo,
+    merkleRoot: string,
+    fileName: string,
+    network: string,
+    blockNumber?: number,
+    ipfsHash?: string,
+    creationTimestamp?: number
+  ): NZipTokenInfo {
+    const networkConfig = NETWORKS[network];
+    
+    return {
+      version: "1.0",
+      tokenId,
+      contractAddress: contractInfo.address,
+      network: networkConfig.name,
+      networkChainId: networkConfig.chainId,
+      transactionHash,
+      merkleRoot,
+      fileName,
+      mintedAt: new Date().toISOString(),
+      creationTimestamp,
+      blockNumber,
+      ipfsHash
+    };
+  }
+
+  /**
+   * Creates the META-INF directory and NZIP.TOKEN file
+   */
+  static async createTokenFile(tokenInfo: NZipTokenInfo): Promise<string> {
+    const currentDir = process.cwd();
+    
+    // Create META-INF directory in current directory
+    const metaInfDir = path.join(currentDir, 'META-INF');
+    if (!fs.existsSync(metaInfDir)) {
+      fs.mkdirSync(metaInfDir, { recursive: true });
+    }
+
+    // Create NZIP.TOKEN file
+    const tokenFilePath = path.join(metaInfDir, 'NZIP.TOKEN');
+    const tokenContent = JSON.stringify(tokenInfo, null, 2);
+    
+    fs.writeFileSync(tokenFilePath, tokenContent);
+    console.log(`Created token metadata file: ${path.relative(currentDir, tokenFilePath)}`);
+    
+    return tokenFilePath;
+  }
+
+  /**
+   * Reads token information from a ZIP file's META-INF/NZIP.TOKEN
+   */
+  static readTokenInfo(zipFilePath: string): NZipTokenInfo | null {
+    // This would require extracting the META-INF/NZIP.TOKEN file from the ZIP
+    // For now, return null - this can be implemented when needed
+    return null;
+  }
+
+  /**
+   * Validates token information structure
+   */
+  static validateTokenInfo(tokenInfo: any): tokenInfo is NZipTokenInfo {
+    return (
+      typeof tokenInfo === 'object' &&
+      typeof tokenInfo.version === 'string' &&
+      typeof tokenInfo.tokenId === 'string' &&
+      typeof tokenInfo.contractAddress === 'string' &&
+      typeof tokenInfo.network === 'string' &&
+      typeof tokenInfo.networkChainId === 'number' &&
+      typeof tokenInfo.transactionHash === 'string' &&
+      typeof tokenInfo.merkleRoot === 'string' &&
+      typeof tokenInfo.fileName === 'string' &&
+      typeof tokenInfo.mintedAt === 'string'
+    );
+  }
+
+  /**
+   * Creates a human-readable summary of the token information
+   */
+  static createTokenSummary(tokenInfo: NZipTokenInfo): string {
+    return `
+═══════════════════════════════════════════════════════════════
+                    NeoZip Token Information
+═══════════════════════════════════════════════════════════════
+Token ID:       ${tokenInfo.tokenId}
+Contract:       ${tokenInfo.contractAddress}
+Network:        ${tokenInfo.network} (Chain ID: ${tokenInfo.networkChainId})
+Transaction:    ${tokenInfo.transactionHash}
+Block Number:   ${tokenInfo.blockNumber || 'Unknown'}
+Merkle Root:    ${tokenInfo.merkleRoot}
+File Name:      ${tokenInfo.fileName}
+Minted At:      ${tokenInfo.mintedAt}
+IPFS Hash:      ${tokenInfo.ipfsHash || 'Not uploaded'}
+Version:        ${tokenInfo.version}
+═══════════════════════════════════════════════════════════════
+    `.trim();
+  }
+
+  /**
+   * No cleanup needed since we write to the current directory
+   */
+  static cleanupTokenFile(tokenFilePath: string): void {
+    // No cleanup needed since we're writing to the current directory
+    // The META-INF/NZIP.TOKEN file should remain in the current directory
+    console.log(`Token metadata file preserved at: ${path.relative(process.cwd(), tokenFilePath)}`);
+  }
+} 

package/src/server/blockchain/ZipTokenProcessor.ts

@@ -0,0 +1,234 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { ethers } from 'ethers';
+import { WalletManager } from './WalletManager';
+import { NFTMinter } from './NFTMinter';
+import { ZipMetadata } from './ZipMetadata';
+import { 
+  MintingOptions, 
+  ZipTokenData, 
+  WalletSetupResult, 
+  MintingResult,
+  ContractInfo,
+  NZipTokenInfo
+} from './types';
+
+interface ProcessorState {
+  walletSetup?: WalletSetupResult;
+  mintingResult?: MintingResult;
+  tokenInfo?: NZipTokenInfo;
+  error?: string;
+}
+
+export class ZipTokenProcessor {
+  private walletManager: WalletManager;
+  private nftMinter: NFTMinter | null = null;
+  private zipTokenData: ZipTokenData;
+
+  constructor(zipFile: string, merkleRoot: string, options: MintingOptions) {
+    this.walletManager = new WalletManager();
+    
+    this.zipTokenData = {
+      zipFile,
+      merkleRoot,
+      fileName: path.basename(zipFile),
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Processes the complete ZIP token workflow
+   */
+  async processZipToken(options: MintingOptions): Promise<ProcessorState> {
+    const state: ProcessorState = {};
+
+    try {
+      // Setup wallet if needed
+      if (options.wallet || options.mintToken) {
+        console.log('Setting up wallet...');
+        const walletResult = await this.walletManager.setupWallet(options);
+        state.walletSetup = walletResult;
+
+        if (!walletResult.success) {
+          state.error = `Wallet setup failed: ${walletResult.message}`;
+          return state;
+        }
+
+        // Initialize NFT minter with wallet and provider
+        this.nftMinter = new NFTMinter(
+          walletResult.wallet,
+          walletResult.provider
+        );
+      }
+
+      // Mint token if requested
+      if (options.mintToken && this.nftMinter) {
+        console.log('Minting NFT token...');
+        const mintingResult = await this.nftMinter.mintZipFileNFT(this.zipTokenData);
+        state.mintingResult = mintingResult;
+
+        if (!mintingResult.success) {
+          state.error = `Minting failed: ${mintingResult.message}`;
+          return state;
+        }
+
+        // Validate that we have complete token data for successful minting
+        if (!mintingResult.tokenId || !mintingResult.txHash) {
+          state.error = `Minting incomplete: Missing token ID or transaction hash`;
+          return state;
+        }
+
+        console.log('Preparing token metadata...');
+        
+        // Check if this was an existing token (message contains "existing token")
+        if (mintingResult.message.includes('existing token')) {
+          console.log('Using existing token from your wallet...');
+          // Create token info from existing token data
+          const tokenInfo = await this.createTokenInfoFromExisting(mintingResult, options);
+          if (!tokenInfo) {
+            state.error = `Failed to create token metadata from existing token`;
+            return state;
+          }
+          state.tokenInfo = tokenInfo;
+        } else {
+          // Create token info from new minting
+          const tokenInfo = this.createTokenInfo(mintingResult, options);
+          if (!tokenInfo) {
+            state.error = `Failed to create token metadata`;
+            return state;
+          }
+          state.tokenInfo = tokenInfo;
+        }
+        
+        console.log('\n' + ZipMetadata.createTokenSummary(state.tokenInfo));
+      }
+
+      return state;
+
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error('Error in ZIP token processing:', error);
+      state.error = `Processing error: ${errorMessage}`;
+      return state;
+    }
+  }
+
+  /**
+   * Gets the ZIP token data
+   */
+  getZipTokenData(): ZipTokenData {
+    return this.zipTokenData;
+  }
+
+  /**
+   * Gets the wallet manager instance
+   */
+  getWalletManager(): WalletManager {
+    return this.walletManager;
+  }
+
+  /**
+   * Gets the NFT minter instance
+   */
+  getNFTMinter(): NFTMinter | null {
+    return this.nftMinter;
+  }
+
+  /**
+   * Loads contract deployment information
+   */
+  private loadContractInfo(): ContractInfo | null {
+    try {
+      const contractInfoPath = path.join(process.cwd(), 'zipfile-nft-deployment.json');
+      
+      if (!fs.existsSync(contractInfoPath)) {
+        return null;
+      }
+      
+      const contractInfo = JSON.parse(fs.readFileSync(contractInfoPath, 'utf8'));
+      return contractInfo as ContractInfo;
+    } catch (error) {
+      console.error('Error loading contract info:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Creates token information object
+   */
+  private createTokenInfo(
+    mintingResult: MintingResult, 
+    options: MintingOptions
+  ): NZipTokenInfo | null {
+    if (!mintingResult.success || !mintingResult.tokenId || !mintingResult.txHash) {
+      console.error('Cannot create token metadata: minting was not successful or missing token data');
+      return null;
+    }
+
+    try {
+      // Load contract information
+      const contractInfo = this.loadContractInfo();
+      if (!contractInfo) {
+        console.error('Cannot load contract information for token metadata');
+        return null;
+      }
+
+      // Create token information with REAL data only
+      const tokenInfo = ZipMetadata.createTokenInfo(
+        mintingResult.tokenId,
+        mintingResult.txHash,
+        contractInfo,
+        this.zipTokenData.merkleRoot,
+        this.zipTokenData.fileName,
+        options.network,
+        undefined, // blockNumber - will be filled later if needed
+        undefined, // ipfsHash - not implemented yet
+        Math.floor(Date.now() / 1000) // creationTimestamp
+      );
+
+      return tokenInfo;
+
+    } catch (error) {
+      console.error('Error creating token metadata:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Creates token information object from existing token
+   */
+  private async createTokenInfoFromExisting(
+    mintingResult: MintingResult, 
+    options: MintingOptions
+  ): Promise<NZipTokenInfo | null> {
+    if (!mintingResult.success || !mintingResult.tokenId || !mintingResult.txHash) {
+      console.error('Cannot create token metadata: minting was not successful or missing token data');
+      return null;
+    }
+
+    try {
+      // Load contract information
+      const contractInfo = this.loadContractInfo();
+      if (!contractInfo) {
+        console.error('Cannot load contract information for token metadata');
+        return null;
+      }
+
+      // Create token information with REAL data only
+      const tokenInfo = ZipMetadata.createTokenInfo(
+        mintingResult.tokenId,
+        mintingResult.txHash,
+        contractInfo,
+        this.zipTokenData.merkleRoot,
+        this.zipTokenData.fileName,
+        options.network
+      );
+
+      return tokenInfo;
+
+    } catch (error) {
+      console.error('Error creating token metadata:', error);
+      return null;
+    }
+  }
+}