neozipkit 0.2.1 → 0.3.0

package/src/blockchain/ZipKitMinter.ts

@@ -1,470 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * ZipKitMinter - Handles NFT token minting for ZIP files
- * Minter API for NZIP-NFT smart contract.
- */
-
-import { ethers } from 'ethers';
-import { NZIP_CONTRACT_ABI, CONTRACT_CONFIGS } from './contracts';
-import type { TokenMetadata } from './types';
-
-// Network configurations
-const NETWORK_CONFIGS = {
-  'base-sepolia': {
-    name: 'Base Sepolia',
-    rpcUrl: 'https://sepolia.base.org',
-    contractAddress: CONTRACT_CONFIGS[84532].address, // Use real contract address
-    explorerUrl: 'https://sepolia.basescan.org',
-    chainId: 84532
-  },
-  'base-mainnet': {
-    name: 'Base Mainnet',
-    rpcUrl: 'https://mainnet.base.org',
-    contractAddress: CONTRACT_CONFIGS[8453].address, // Use real contract address
-    explorerUrl: 'https://basescan.org',
-    chainId: 8453
-  }
-};
-
-export interface MintingOptions {
-  walletPrivateKey: string;
-  network: string;
-  verbose?: boolean;
-  debug?: boolean;
-}
-
-export interface MintingResult {
-  success: boolean;
-  message: string;
-  tokenId?: string;
-  transactionHash?: string;
-  contractAddress?: string;
-  blockNumber?: number;
-  walletAddress?: string;
-  gasUsed?: string;
-  gasCost?: string;
-}
-
-export interface TokenInfo {
-  tokenId: string;
-  owner: string;
-  isOwnedByUser: boolean;
-  tokenData?: any;
-}
-
-export interface DuplicateCheckResult {
-  hasExistingTokens: boolean;
-  allTokens: TokenInfo[];
-  userOwnedTokens: TokenInfo[];
-  othersTokens: TokenInfo[];
-}
-
-export interface WalletInfo {
-  address: string;
-  balance: string;
-  networkName: string;
-}
-
-/**
- * Blockchain Token Minter for ZIP files
- */
-export class ZipKitMinter {
-  private provider: ethers.JsonRpcProvider;
-  private wallet: ethers.Wallet;
-  private contract: ethers.Contract;
-  private merkleRoot: string;
-  private archiveName: string;
-  private networkConfig: any;
-  private debug: boolean;
-  
-  constructor(archiveName: string, merkleRoot: string, options: MintingOptions) {
-    this.archiveName = archiveName;
-    this.merkleRoot = merkleRoot;
-    this.debug = options.debug || false;
-    
-    // Get network configuration
-    this.networkConfig = NETWORK_CONFIGS[options.network as keyof typeof NETWORK_CONFIGS];
-    if (!this.networkConfig) {
-      throw new Error(`Unsupported network: ${options.network}`);
-    }
-    
-    // Initialize provider for the specified network
-    this.provider = new ethers.JsonRpcProvider(this.networkConfig.rpcUrl);
-    
-    // Initialize wallet from private key
-    this.wallet = new ethers.Wallet(options.walletPrivateKey, this.provider);
-    
-    // Initialize contract instance
-    this.contract = new ethers.Contract(
-      this.networkConfig.contractAddress,
-      NZIP_CONTRACT_ABI,
-      this.wallet
-    );
-
-    if (this.debug) {
-      console.log(`[DEBUG] ZipKitMinter initialized for ${this.networkConfig.name}`);
-      console.log(`[DEBUG] Archive: ${archiveName}, Merkle: ${merkleRoot.substring(0, 10)}...`);
-    }
-  }
-
-  /**
-   * Get wallet information
-   */
-  async getWalletInfo(): Promise<WalletInfo> {
-    const balance = await this.provider.getBalance(this.wallet.address);
-    const balanceInEth = ethers.formatEther(balance);
-    
-    if (this.debug) {
-      console.log(`[DEBUG] Wallet ${this.wallet.address} balance: ${balanceInEth} ETH`);
-    }
-    
-    return {
-      address: this.wallet.address,
-      balance: balanceInEth,
-      networkName: this.networkConfig.name
-    };
-  }
-
-  /**
-   * Check for existing tokens with same merkle root and verify ownership
-   */
-  async checkForDuplicates(): Promise<DuplicateCheckResult> {
-    try {
-      if (this.debug) {
-        console.log(`[DEBUG] Checking for existing tokens with merkle root: ${this.merkleRoot}`);
-        console.log(`[DEBUG] User wallet address: ${this.wallet.address}`);
-      }
-
-      // Call contract method to check if merkle root already exists
-      const existingTokenIds = await this.contract.getTokensByMerkleRoot(this.merkleRoot);
-      
-      if (!existingTokenIds || existingTokenIds.length === 0) {
-        if (this.debug) {
-          console.log(`[DEBUG] No existing tokens found for this merkle root`);
-        }
-        return {
-          hasExistingTokens: false,
-          allTokens: [],
-          userOwnedTokens: [],
-          othersTokens: []
-        };
-      }
-
-      if (this.debug) {
-        console.log(`[DEBUG] Found ${existingTokenIds.length} existing token(s)`);
-      }
-
-      // Check ownership and get token details for each token
-      const allTokens: TokenInfo[] = [];
-      const userOwnedTokens: TokenInfo[] = [];
-      const othersTokens: TokenInfo[] = [];
-
-      for (const tokenId of existingTokenIds) {
-        const tokenIdStr = tokenId.toString();
-        
-        try {
-          // Get token owner
-          const owner = await this.contract.ownerOf(tokenId);
-          const isOwnedByUser = owner.toLowerCase() === this.wallet.address.toLowerCase();
-          
-          // Get token data
-          let tokenData = null;
-          try {
-            tokenData = await this.contract.getZipFileInfo(tokenId);
-          } catch (e) {
-            if (this.debug) {
-              console.log(`[DEBUG] Could not get token data for ${tokenIdStr}: ${e}`);
-            }
-          }
-
-          const tokenInfo: TokenInfo = {
-            tokenId: tokenIdStr,
-            owner: owner,
-            isOwnedByUser: isOwnedByUser,
-            tokenData: tokenData
-          };
-
-          allTokens.push(tokenInfo);
-          
-          if (isOwnedByUser) {
-            userOwnedTokens.push(tokenInfo);
-            if (this.debug) {
-              console.log(`[DEBUG] Token ${tokenIdStr} is owned by user`);
-            }
-          } else {
-            othersTokens.push(tokenInfo);
-            if (this.debug) {
-              console.log(`[DEBUG] Token ${tokenIdStr} is owned by ${owner}`);
-            }
-          }
-
-        } catch (e) {
-          if (this.debug) {
-            console.log(`[DEBUG] Error checking ownership for token ${tokenIdStr}: ${e}`);
-          }
-        }
-      }
-
-      return {
-        hasExistingTokens: true,
-        allTokens,
-        userOwnedTokens,
-        othersTokens
-      };
-      
-    } catch (error) {
-      if (this.debug) {
-        console.log(`[DEBUG] Error checking duplicates: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      }
-      
-      // If the contract method doesn't exist or fails, assume no duplicates
-      return {
-        hasExistingTokens: false,
-        allTokens: [],
-        userOwnedTokens: [],
-        othersTokens: []
-      };
-    }
-  }
-
-  /**
-   * Estimate gas costs for minting
-   */
-  async estimateGasCosts(): Promise<{ gasLimit: bigint; gasPrice: bigint; estimatedCost: string }> {
-    const creationTimestamp = Math.floor(Date.now() / 1000);
-    const metadata = this.createTokenMetadataString();
-
-    // Estimate gas for the minting transaction
-    const gasLimit = await this.contract.publicMintZipFile.estimateGas(
-      this.archiveName,
-      this.merkleRoot,
-      creationTimestamp,
-      '', // ipfsHash
-      metadata
-    );
-
-    const feeData = await this.provider.getFeeData();
-    const gasPrice = feeData.gasPrice || BigInt(0);
-    const estimatedCost = ethers.formatEther(gasLimit * gasPrice);
-
-    if (this.debug) {
-      console.log(`[DEBUG] Gas estimate - Limit: ${gasLimit}, Price: ${gasPrice}, Cost: ${estimatedCost} ETH`);
-    }
-
-    return { gasLimit, gasPrice, estimatedCost };
-  }
-
-  /**
-   * Create token metadata string
-   */
-  private createTokenMetadataString(): string {
-    const now = new Date();
-    return JSON.stringify({
-      name: `NeoZip Archive: ${this.archiveName}`,
-      description: `Tokenized ZIP archive with cryptographic proof of integrity`,
-      image: '', // Could be a thumbnail or icon
-      archiveName: this.archiveName,
-      merkleRoot: this.merkleRoot,
-      network: this.networkConfig.name,
-      createdAt: now.toISOString(),
-      timestamp: Math.floor(now.getTime() / 1000)
-    });
-  }
-
-  /**
-   * Create TokenMetadata object from minting result
-   */
-  private createTokenMetadata(tokenId: string, transactionHash: string, blockNumber?: number): TokenMetadata {
-    const now = new Date();
-    
-    return {
-      tokenId,
-      network: this.networkConfig.name,
-      contractAddress: this.networkConfig.contractAddress,
-      merkleRoot: this.merkleRoot,
-      mintDate: now.toLocaleDateString('en-US') + ' at ' + now.toLocaleTimeString('en-US'),
-      creationTimestamp: Math.floor(now.getTime() / 1000),
-      archiveName: this.archiveName,
-      transactionHash,
-      blockNumber
-    };
-  }
-
-  /**
-   * Mint new token on blockchain
-   */
-  async mintToken(): Promise<MintingResult> {
-    try {
-      if (this.debug) {
-        console.log(`[DEBUG] Starting token minting process`);
-      }
-
-      // Generate token ID (could be random or sequential)
-      const tokenId = Math.floor(Math.random() * 1000000).toString();
-      const metadata = this.createTokenMetadataString();
-      const creationTimestamp = Math.floor(Date.now() / 1000);
-
-      if (this.debug) {
-        console.log(`[DEBUG] Generated token ID: ${tokenId}`);
-        console.log(`[DEBUG] Metadata: ${metadata.substring(0, 100)}...`);
-      }
-
-      // Call the contract publicMintZipFile function
-      const tx = await this.contract.publicMintZipFile(
-        this.archiveName,
-        this.merkleRoot,
-        creationTimestamp,
-        '', // ipfsHash (empty since we store in ZIP)
-        metadata
-      );
-
-      if (this.debug) {
-        console.log(`[DEBUG] Transaction submitted: ${tx.hash}`);
-      }
-
-      // Wait for transaction confirmation
-      const receipt = await tx.wait();
-
-      if (this.debug) {
-        console.log(`[DEBUG] Transaction confirmed in block: ${receipt.blockNumber}`);
-        console.log(`[DEBUG] Gas used: ${receipt.gasUsed}`);
-      }
-
-      // Extract actual token ID from contract events
-      let actualTokenId = tokenId; // fallback
-      
-      if (receipt.logs && receipt.logs.length > 0) {
-        try {
-          const iface = new ethers.Interface(NZIP_CONTRACT_ABI);
-          for (const log of receipt.logs) {
-            try {
-              const parsed = iface.parseLog(log);
-              if (parsed?.name === 'ZipFileTokenized') {
-                actualTokenId = parsed.args.tokenId.toString();
-                if (this.debug) {
-                  console.log(`[DEBUG] Actual token ID from contract event: ${actualTokenId}`);
-                }
-                break;
-              }
-            } catch (e) {
-              // Ignore parsing errors for non-matching logs
-            }
-          }
-        } catch (e) {
-          if (this.debug) {
-            console.log(`[DEBUG] Could not parse token ID from logs: ${e}`);
-          }
-        }
-      }
-
-      const gasCost = ethers.formatEther(receipt.gasUsed * (receipt.gasPrice || BigInt(0)));
-
-      return {
-        success: true,
-        message: `Token successfully minted`,
-        tokenId: actualTokenId,
-        transactionHash: tx.hash,
-        contractAddress: this.networkConfig.contractAddress,
-        blockNumber: receipt.blockNumber,
-        walletAddress: this.wallet.address,
-        gasUsed: receipt.gasUsed.toString(),
-        gasCost
-      };
-
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown minting error';
-      
-      if (this.debug) {
-        console.log(`[DEBUG] Minting failed: ${errorMessage}`);
-      }
-
-      return {
-        success: false,
-        message: errorMessage
-      };
-    }
-  }
-
-  /**
-   * Main minting process - checks for duplicates, then mints if needed
-   */
-  async processMinting(): Promise<{
-    walletInfo: WalletInfo;
-    duplicateCheck: DuplicateCheckResult;
-    gasCosts?: { gasLimit: bigint; gasPrice: bigint; estimatedCost: string };
-    mintingResult?: MintingResult;
-    tokenMetadata?: TokenMetadata;
-  }> {
-    try {
-      // Get wallet information
-      const walletInfo = await this.getWalletInfo();
-
-      // Check for duplicates first (free operation)
-      const duplicateCheck = await this.checkForDuplicates();
-
-      if (duplicateCheck.hasExistingTokens) {
-        if (this.debug) {
-          console.log(`[DEBUG] Existing tokens found, user will choose`);
-        }
-        
-        return {
-          walletInfo,
-          duplicateCheck
-        };
-      }
-
-      // Estimate gas costs
-      const gasCosts = await this.estimateGasCosts();
-
-      // This is where the user would be prompted for confirmation in the calling code
-      // The actual minting happens in a separate call to mintToken()
-
-      return {
-        walletInfo,
-        duplicateCheck,
-        gasCosts
-      };
-
-    } catch (error) {
-      throw new Error(`Minting process failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  /**
-   * Complete the minting after user confirmation
-   */
-  async completeMinting(): Promise<{
-    mintingResult: MintingResult;
-    tokenMetadata?: TokenMetadata;
-  }> {
-    const mintingResult = await this.mintToken();
-
-    if (mintingResult.success && mintingResult.tokenId && mintingResult.transactionHash) {
-      const tokenMetadata = this.createTokenMetadata(
-        mintingResult.tokenId,
-        mintingResult.transactionHash,
-        mintingResult.blockNumber
-      );
-
-      return {
-        mintingResult,
-        tokenMetadata
-      };
-    }
-
-    return { mintingResult };
-  }
-}
-
-/**
- * Utility function to validate Ethereum private key
- */
-export function validatePrivateKey(privateKey: string): boolean {
-  try {
-    new ethers.Wallet(privateKey);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/blockchain/ZipKitNFT.ts

@@ -1,12 +0,0 @@
-// Re-export NFT classes and types without aliases
-export { ZipKitMinter, ZipKitVerifier } from '.';
-export type {
-  MintingOptions,
-  MintingResult,
-  DuplicateCheckResult,
-  TokenInfo,
-  WalletInfo,
-  VerificationOptions,
-  VerificationResult,
-} from '.';
-export type { TokenMetadata } from './types';