neozipkit 0.1.1

package/src/server/blockchain/NFTMinter.ts

@@ -0,0 +1,357 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ethers } from 'ethers';
+import { 
+  MintingResult, 
+  ContractInfo, 
+  ZipTokenData, 
+  NFTMetadata,
+  NFT_METADATA_TEMPLATE 
+} from './types';
+
+export interface ExistingTokenInfo {
+  tokenId: string;
+  fileName: string;
+  merkleRootHash: string;
+  creationTimestamp: number;
+  tokenizationTime: number;
+  creator: string;
+  isOwnedByWallet: boolean;
+}
+
+export class NFTMinter {
+  private wallet: ethers.Wallet | null;
+  private provider: ethers.JsonRpcProvider | null;
+
+  constructor(wallet: ethers.Wallet | null, provider: ethers.JsonRpcProvider | null) {
+    this.wallet = wallet;
+    this.provider = provider;
+  }
+
+  /**
+   * Creates NFT metadata for the ZIP archive
+   */
+  createNFTMetadata(zipTokenData: ZipTokenData): NFTMetadata {
+    const metadata = { ...NFT_METADATA_TEMPLATE };
+    metadata.name = `${zipTokenData.fileName} Archive`;
+    metadata.description = `Verified archive created on ${zipTokenData.timestamp}`;
+    metadata.attributes[0].value = zipTokenData.merkleRoot;
+    metadata.attributes[1].value = zipTokenData.timestamp;
+    
+    return metadata;
+  }
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * Check for existing tokens with the same merkle root
+   * This is efficient because it uses the contract's getTokensByMerkleRoot function
+   */
+  async findExistingTokensByMerkleRoot(merkleRoot: string): Promise<ExistingTokenInfo[]> {
+    if (!this.provider || !this.wallet) {
+      return [];
+    }
+
+    try {
+      const contractInfo = this.loadContractInfo();
+      if (!contractInfo) {
+        return [];
+      }
+
+      console.log(`🔍 Checking for existing tokens with merkle root: ${merkleRoot}`);
+      const contract = new ethers.Contract(contractInfo.address, contractInfo.abi, this.provider);
+      
+      // Use the efficient contract function to get tokens by merkle root
+      const tokenIds = await contract.getTokensByMerkleRoot(merkleRoot);
+      
+      if (tokenIds.length === 0) {
+        console.log(`   ✅ No existing tokens found for this content`);
+        return [];
+      }
+
+      console.log(`   📋 Found ${tokenIds.length} existing token(s) for this content:`);
+      
+      const existingTokens: ExistingTokenInfo[] = [];
+      
+      for (const tokenId of tokenIds) {
+        try {
+          // Get token info
+          const zipInfo = await contract.getZipFileInfo(tokenId);
+          const owner = await contract.ownerOf(tokenId);
+          
+          const tokenInfo: ExistingTokenInfo = {
+            tokenId: tokenId.toString(),
+            fileName: zipInfo.fileName,
+            merkleRootHash: zipInfo.merkleRootHash,
+            creationTimestamp: Number(zipInfo.creationTimestamp),
+            tokenizationTime: Number(zipInfo.tokenizationTime),
+            creator: zipInfo.creator,
+            isOwnedByWallet: owner.toLowerCase() === this.wallet!.address.toLowerCase()
+          };
+          
+          existingTokens.push(tokenInfo);
+          
+          const ownershipStatus = tokenInfo.isOwnedByWallet ? "👤 (owned by you)" : `👥 (owned by ${owner})`;
+          const createdDate = new Date(tokenInfo.creationTimestamp * 1000).toISOString();
+          const mintedDate = new Date(tokenInfo.tokenizationTime * 1000).toISOString();
+          
+          console.log(`   📄 Token ID ${tokenInfo.tokenId}: ${tokenInfo.fileName}`);
+          console.log(`      Created: ${createdDate}`);
+          console.log(`      Minted:  ${mintedDate}`);
+          console.log(`      Owner:   ${ownershipStatus}`);
+          
+        } catch (error) {
+          console.warn(`   ⚠️  Could not retrieve info for token ${tokenId}: ${error}`);
+        }
+      }
+      
+      return existingTokens;
+      
+    } catch (error) {
+      console.warn(`Error checking for existing tokens: ${error}`);
+      return [];
+    }
+  }
+
+  /**
+   * Prompts user to choose between reusing an existing timestamp or creating a new token
+   */
+  async promptUserChoice(existingTokens: ExistingTokenInfo[], fileName: string): Promise<{
+    useExisting: boolean;
+    selectedTimestamp?: number;
+    selectedTokenId?: string;
+  }> {
+    return new Promise((resolve) => {
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      console.log('\n🤔 What would you like to do?');
+      console.log('═'.repeat(60));
+      console.log('1. Create a new token with current timestamp (recommended)');
+      
+      // Show existing tokens as options
+      existingTokens.forEach((token, index) => {
+        const createdDate = new Date(token.creationTimestamp * 1000).toLocaleString();
+        const ownershipNote = token.isOwnedByWallet ? ' (you own this)' : ` (owned by ${token.creator.slice(0, 8)}...)`;
+        console.log(`${index + 2}. Reuse timestamp from Token ${token.tokenId}: ${createdDate}${ownershipNote}`);
+      });
+      
+      console.log('═'.repeat(60));
+
+      rl.question('Enter your choice (1-' + (existingTokens.length + 1) + '): ', (answer: string) => {
+        rl.close();
+        
+        const choice = parseInt(answer.trim());
+        
+        if (choice === 1) {
+          resolve({ useExisting: false });
+        } else if (choice >= 2 && choice <= existingTokens.length + 1) {
+          const selectedToken = existingTokens[choice - 2];
+          resolve({ 
+            useExisting: true, 
+            selectedTimestamp: selectedToken.creationTimestamp,
+            selectedTokenId: selectedToken.tokenId
+          });
+        } else {
+          console.log('❌ Invalid choice. Creating new token with current timestamp.');
+          resolve({ useExisting: false });
+        }
+      });
+    });
+  }
+
+  /**
+   * Mints an NFT token for the ZIP archive using the timestamped contract
+   */
+  async mintZipFileNFT(zipTokenData: ZipTokenData): Promise<MintingResult> {
+    if (!this.wallet) {
+      return {
+        success: false,
+        message: 'Wallet not set up. Cannot mint token.'
+      };
+    }
+
+    if (!this.provider) {
+      return {
+        success: false,
+        message: 'Network connection failed. Cannot mint token without blockchain connectivity.'
+      };
+    }
+
+    try {
+      console.log(`\nArchive Merkle root: ${zipTokenData.merkleRoot}`);
+      
+      // Check for existing tokens with the same merkle root
+      const existingTokens = await this.findExistingTokensByMerkleRoot(zipTokenData.merkleRoot);
+      
+      let creationTimestamp: number;
+      let reusingExistingToken = false;
+      let selectedTokenId: string | undefined;
+      
+      if (existingTokens.length > 0) {
+        console.log(`\n💡 Found ${existingTokens.length} existing token(s) with the same content.`);
+        console.log('   You can create a new token or reuse an existing timestamp.');
+        
+        const userChoice = await this.promptUserChoice(existingTokens, zipTokenData.fileName);
+        
+        if (userChoice.useExisting && userChoice.selectedTimestamp) {
+          creationTimestamp = userChoice.selectedTimestamp;
+          selectedTokenId = userChoice.selectedTokenId;
+          reusingExistingToken = true;
+          console.log(`\n✅ Reusing timestamp ${creationTimestamp} from Token ID ${selectedTokenId}`);
+          
+          // Check if this exact combination already exists
+          const contractInfo = this.loadContractInfo();
+          if (contractInfo) {
+            const contract = new ethers.Contract(contractInfo.address, contractInfo.abi, this.provider);
+            const [exists, existingTokenId] = await contract.isZipFileTokenized(zipTokenData.merkleRoot, creationTimestamp);
+            
+            if (exists) {
+              return {
+                success: false,
+                message: `A token with this exact merkle root and timestamp already exists (Token ID: ${existingTokenId}). Cannot create duplicate.`
+              };
+            }
+          }
+        } else {
+          creationTimestamp = Math.floor(Date.now() / 1000);
+          console.log(`\n✅ Creating new token with current timestamp: ${creationTimestamp}`);
+        }
+      } else {
+        // No existing tokens, use current timestamp
+        creationTimestamp = Math.floor(Date.now() / 1000);
+        console.log('Creating new NFT token for this ZIP archive...');
+      }
+      
+      // Create token metadata
+      const metadata = this.createNFTMetadata(zipTokenData);
+      
+      console.log('Token metadata created:');
+      console.log(JSON.stringify(metadata, null, 2));
+      
+      // Load contract information
+      const contractInfo = this.loadContractInfo();
+      
+      if (!contractInfo) {
+        return {
+          success: false,
+          message: 'No deployed contract found. Deploy the contract using: npm run deploy-nft'
+        };
+      }
+      
+      console.log(`Found deployed contract at ${contractInfo.address}`);
+      
+      try {
+        // Create contract instance
+        const contract = new ethers.Contract(contractInfo.address, contractInfo.abi, this.wallet);
+        
+        console.log(`\nMinting NFT token...`);
+        console.log(`Merkle Root: ${zipTokenData.merkleRoot}`);
+        console.log(`Creation Timestamp: ${creationTimestamp}${reusingExistingToken ? ' (reused)' : ' (new)'}`);
+        
+        // Use the timestamped contract (5 parameters)
+        console.log(`Using ZipFileNFT contract`);
+        console.log(`contract.publicMintZipFile(`);
+        console.log(`  fileName: ${zipTokenData.fileName},`);
+        console.log(`  merkleRootHash: ${zipTokenData.merkleRoot},`);
+        console.log(`  creationTimestamp: ${creationTimestamp},`);
+        console.log(`  ipfsHash: "",`);
+        console.log(`  tokenURI: ""`);
+        console.log(`)`);
+        
+        const tx = await contract.publicMintZipFile(
+          zipTokenData.fileName,
+          zipTokenData.merkleRoot, // Use original merkle root
+          creationTimestamp, // Use selected timestamp (new or reused)
+          "", // Empty ipfsHash - not implemented yet
+          ""  // Empty tokenURI - not implemented yet
+        );
+        
+        console.log(`Transaction submitted: ${tx.hash}`);
+        console.log('Waiting for confirmation...');
+        
+        const receipt = await tx.wait();
+        console.log(`Transaction confirmed in block: ${receipt.blockNumber}`);
+        
+        // Extract token ID from the transfer event
+        let tokenId: string | undefined;
+        for (const log of receipt.logs) {
+          try {
+            const parsedLog = contract.interface.parseLog(log);
+            if (parsedLog && parsedLog.name === 'Transfer' && parsedLog.args.from === ethers.ZeroAddress) {
+              tokenId = parsedLog.args.tokenId.toString();
+              break;
+            }
+          } catch (error) {
+            // Skip logs that can't be parsed
+          }
+        }
+        
+        if (!tokenId) {
+          // Try to get token ID from ZipFileTokenized event
+          for (const log of receipt.logs) {
+            try {
+              const parsedLog = contract.interface.parseLog(log);
+              if (parsedLog && parsedLog.name === 'ZipFileTokenized') {
+                tokenId = parsedLog.args.tokenId.toString();
+                break;
+              }
+            } catch (error) {
+              // Skip logs that can't be parsed
+            }
+          }
+        }
+        
+        const successMessage = reusingExistingToken 
+          ? `NFT minted successfully! Token ID: ${tokenId || 'Unknown'} (reused timestamp from Token ${selectedTokenId})`
+          : `NFT minted successfully! Token ID: ${tokenId || 'Unknown'} (new timestamp)`;
+        
+        return {
+          success: true,
+          txHash: tx.hash,
+          tokenId: tokenId,
+          message: successMessage,
+          creationTimestamp: creationTimestamp
+        };
+        
+      } catch (contractError: unknown) {
+        const errorMessage = contractError instanceof Error ? contractError.message : String(contractError);
+        console.error(`Contract interaction failed: ${errorMessage}`);
+        
+        return {
+          success: false,
+          message: `Contract interaction failed: ${errorMessage}`
+        };
+      }
+      
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`Error minting NFT: ${errorMessage}`);
+      
+      return {
+        success: false,
+        message: `Error minting NFT: ${errorMessage}`
+      };
+    }
+  }
+} 

package/src/server/blockchain/TokenQuerier.ts

@@ -0,0 +1,287 @@
+// ======================================
+//	TokenQuerier.ts
+//  Blockchain token querying utilities for ZIP archives
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { CURRENT_DEPLOYMENT } from './constants';
+
+// Network configuration for blockchain queries
+const NETWORK_CONFIG: Record<string, any> = {
+  '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'
+    ],
+    contractAddress: CURRENT_DEPLOYMENT.address, // NZIP NFT Contract v2.0
+    chainId: 84532
+  },
+  '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'
+    ],
+    contractAddress: "0x...", // Add mainnet contract address when deployed
+    chainId: 8453
+  }
+};
+
+export interface ExistingTokenInfo {
+  version: string;
+  tokenId: string;
+  contractAddress: string;
+  network: string;
+  networkChainId: number;
+  transactionHash?: string;
+  merkleRoot: string;
+  fileName: string;
+  mintedAt: string;
+}
+
+export interface TokenQueryOptions {
+  network?: string;
+  walletAddress?: string;
+  contractAddress?: string;
+}
+
+/**
+ * Queries the blockchain for an existing token with the given merkle root
+ * @param merkleRoot - The merkle root hash to search for
+ * @param fileName - The name of the ZIP file
+ * @param options - Optional query parameters
+ * @returns Promise resolving to token info if found, null otherwise
+ */
+export async function queryBlockchainForExistingToken(
+  merkleRoot: string, 
+  fileName: string,
+  options: TokenQueryOptions = {}
+): Promise<ExistingTokenInfo | null> {
+  try {
+    const { ethers } = await import('ethers');
+    
+    // Use Base Sepolia as default network
+    const network = options.network || 'Base Sepolia';
+    const networkConfig = NETWORK_CONFIG[network];
+    
+    if (!networkConfig) {
+      console.log(`⚠️  Unsupported network: ${network}`);
+      return null;
+    }
+    
+    // Load the contract ABI from deployment file
+    const deploymentPath = path.join(process.cwd(), 'zipfile-nft-deployment.json');
+    
+    if (!fs.existsSync(deploymentPath)) {
+      console.log(`⚠️  Deployment file not found: ${deploymentPath}`);
+      return null;
+    }
+    
+    const deploymentInfo = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+    const contractAddress = options.contractAddress || networkConfig.contractAddress;
+    
+    // Default wallet address - this should ideally be passed in from the calling context
+    const walletAddress = options.walletAddress || "0x6d4d3075d102376164818471c2f974b9ef211df2";
+    
+    // Try multiple RPC endpoints
+    for (const rpcUrl of networkConfig.rpcUrls) {
+      try {
+        console.log(`   Trying RPC: ${rpcUrl}`);
+        const provider = new ethers.JsonRpcProvider(rpcUrl);
+        const contract = new ethers.Contract(contractAddress, deploymentInfo.abi, provider);
+        
+        // Get balance of current wallet to know how many tokens to check
+        const balance = await contract.balanceOf(walletAddress);
+        console.log(`   Wallet owns ${balance} tokens, checking each for merkle root match...`);
+        
+        // Search through wallet's tokens to find one with our merkle root
+        // First try: Query the ZipFileTokenized events for efficiency
+        try {
+          const filter = contract.filters.ZipFileTokenized();
+          const events = await contract.queryFilter(filter, 0, 'latest');
+          
+          for (const event of events) {
+            if ('args' in event && event.args) {
+              const tokenId = event.args.tokenId.toString();
+              const eventMerkleRoot = event.args.merkleRootHash;
+              const eventCreator = event.args.creator;
+              
+              // Check if this is our token (same merkle root and created by our wallet)
+              if (eventMerkleRoot === merkleRoot && eventCreator.toLowerCase() === walletAddress.toLowerCase()) {
+                console.log(`   ✅ Found token ${tokenId} with matching merkle root (created by our wallet)`);
+                
+                // Get block timestamp for more accurate mint time
+                const block = await provider.getBlock(event.blockNumber);
+                const mintTime = block ? new Date(block.timestamp * 1000).toISOString() : new Date().toISOString();
+                
+                // Create token metadata with the information we have
+                const tokenInfo: ExistingTokenInfo = {
+                  version: "1.0",
+                  tokenId: tokenId,
+                  contractAddress: contractAddress,
+                  network: network,
+                  networkChainId: networkConfig.chainId,
+                  transactionHash: event.transactionHash,
+                  merkleRoot: merkleRoot,
+                  fileName: fileName,
+                  mintedAt: mintTime
+                };
+                
+                return tokenInfo;
+              }
+            }
+          }
+        } catch (eventError) {
+          console.log(`   ⚠️  Event query failed, trying direct token scan...`);
+          
+          // Fallback: try scanning recent token IDs directly
+          const totalSupply = await contract.totalSupply();
+          console.log(`   Scanning ${totalSupply} total tokens...`);
+          
+          // Limit scanning to avoid RPC timeouts
+          const maxTokensToScan = Math.min(Number(totalSupply), 1000);
+          
+          for (let tokenId = 0; tokenId < maxTokensToScan; tokenId++) {
+            try {
+              const owner = await contract.ownerOf(tokenId);
+              if (owner.toLowerCase() === walletAddress.toLowerCase()) {
+                const zipInfo = await contract.getZipFileInfo(tokenId);
+                
+                if (zipInfo.merkleRootHash === merkleRoot) {
+                  console.log(`   ✅ Found token ${tokenId} with matching merkle root (owned by our wallet)`);
+                  
+                  const tokenInfo: ExistingTokenInfo = {
+                    version: "1.0",
+                    tokenId: tokenId.toString(),
+                    contractAddress: contractAddress,
+                    network: network,
+                    networkChainId: networkConfig.chainId,
+                    merkleRoot: merkleRoot,
+                    fileName: fileName,
+                    mintedAt: new Date(Number(zipInfo.tokenizationTime) * 1000).toISOString()
+                  };
+                  
+                  return tokenInfo;
+                }
+              }
+            } catch (tokenError) {
+              // Token might not exist or be accessible, continue searching
+              continue;
+            }
+          }
+          
+          if (Number(totalSupply) > maxTokensToScan) {
+            console.log(`   ⚠️  Only scanned first ${maxTokensToScan} tokens (total: ${totalSupply})`);
+          }
+        }
+        
+        console.log('   ❌ No token found with matching merkle root');
+        return null;
+        
+      } catch (rpcError) {
+        const errorMessage = rpcError instanceof Error ? rpcError.message : String(rpcError);
+        console.log(`   ⚠️  RPC ${rpcUrl} failed: ${errorMessage.substring(0, 80)}...`);
+        continue;
+      }
+    }
+    
+    console.log('   ❌ All RPC endpoints failed');
+    return null;
+    
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log('   ❌ Blockchain query failed:', errorMessage);
+    return null;
+  }
+}
+
+/**
+ * Queries all tokens owned by a specific wallet address
+ * @param walletAddress - The wallet address to query
+ * @param options - Optional query parameters
+ * @returns Promise resolving to array of token info
+ */
+export async function queryWalletTokens(
+  walletAddress: string,
+  options: TokenQueryOptions = {}
+): Promise<ExistingTokenInfo[]> {
+  try {
+    const { ethers } = await import('ethers');
+    
+    const network = options.network || 'Base Sepolia';
+    const networkConfig = NETWORK_CONFIG[network];
+    
+    if (!networkConfig) {
+      console.log(`⚠️  Unsupported network: ${network}`);
+      return [];
+    }
+    
+    const deploymentPath = path.join(process.cwd(), 'zipfile-nft-deployment.json');
+    
+    if (!fs.existsSync(deploymentPath)) {
+      console.log(`⚠️  Deployment file not found: ${deploymentPath}`);
+      return [];
+    }
+    
+    const deploymentInfo = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
+    const contractAddress = options.contractAddress || networkConfig.contractAddress;
+    
+    const tokens: ExistingTokenInfo[] = [];
+    
+    // Try the first available RPC endpoint
+    const rpcUrl = networkConfig.rpcUrls[0];
+    try {
+      const provider = new ethers.JsonRpcProvider(rpcUrl);
+      const contract = new ethers.Contract(contractAddress, deploymentInfo.abi, provider);
+      
+      const balance = await contract.balanceOf(walletAddress);
+      console.log(`   Wallet ${walletAddress} owns ${balance} tokens`);
+      
+      // Query events for tokens created by this wallet
+      const filter = contract.filters.ZipFileTokenized();
+      const events = await contract.queryFilter(filter, 0, 'latest');
+      
+      for (const event of events) {
+        if ('args' in event && event.args) {
+          const eventCreator = event.args.creator;
+          
+          if (eventCreator.toLowerCase() === walletAddress.toLowerCase()) {
+            const tokenId = event.args.tokenId.toString();
+            const merkleRoot = event.args.merkleRootHash;
+            
+            const block = await provider.getBlock(event.blockNumber);
+            const mintTime = block ? new Date(block.timestamp * 1000).toISOString() : new Date().toISOString();
+            
+            const tokenInfo: ExistingTokenInfo = {
+              version: "1.0",
+              tokenId: tokenId,
+              contractAddress: contractAddress,
+              network: network,
+              networkChainId: networkConfig.chainId,
+              transactionHash: event.transactionHash,
+              merkleRoot: merkleRoot,
+              fileName: `token-${tokenId}.zip`, // Placeholder filename
+              mintedAt: mintTime
+            };
+            
+            tokens.push(tokenInfo);
+          }
+        }
+      }
+      
+    } catch (error) {
+      console.log('   ❌ Failed to query wallet tokens:', error instanceof Error ? error.message : String(error));
+    }
+    
+    return tokens;
+    
+  } catch (error) {
+    console.log('   ❌ Wallet query failed:', error instanceof Error ? error.message : String(error));
+    return [];
+  }
+}