neozipkit 0.1.1 → 0.2.1

package/src/blockchain/README.md

@@ -0,0 +1,229 @@
+## Blockchain Module APIs
+
+This directory provides all blockchain-related functionality for NeoZipKit, including:
+- OpenTimestamps utilities
+- NFT contract interactions (verification, querying, minting)
+- Wallet utilities and token processing
+- Network constants and contract ABI
+
+## 📁 Module Structure
+
+```
+src/blockchain/
+├── contracts.ts             # Contract ABI + network configs + addresses
+├── ZipKitOTS.ts             # OpenTimestamps utilities
+├── TokenVerifier.ts         # ZIP tokenization verification
+├── TokenQuerier.ts          # Blockchain token queries
+├── NFTMinter.ts             # NFT minting operations
+├── WalletManager.ts         # Wallet connection management
+├── WalletAnalyzer.ts        # Wallet token analysis
+├── (removed)                # Token display formatting (deprecated)
+├── ZipMetadata.ts           # ZIP metadata validation
+├── ZipKitMinter.ts          # High-level minting interface
+├── ZipKitVerifier.ts        # High-level verification interface
+├── ZipKitNFT.ts             # Unified NFT facade (minter + verifier)
+├── ZipKitWallet.ts          # Wallet setup + WalletAnalyzer utilities (combined)
+├── ZipTokenProcessor.ts     # Token processing utilities
+├── types.ts                 # Shared blockchain types
+└── index.ts                 # Module exports
+```
+
+### Package Entry
+Import from the package root or from `src/blockchain` directly:
+
+```ts
+// Yes! You can import directly from the blockchain directory
+import { 
+  ZipMetadata,
+  ZipKitMinter,
+  ZipKitVerifier,
+  ZipKitWallet,
+  WalletAnalyzer,
+  CONTRACT_CONFIGS,
+  NZIP_CONTRACT_ABI,
+  CURRENT_DEPLOYMENT
+} from 'neozipkit/blockchain';
+
+// Or from the main package (re-exports everything from blockchain)
+import { ZipMetadata, ZipKitMinter, ZipKitVerifier, ZipKitWallet, WalletAnalyzer } from 'neozipkit';
+
+// From source (monorepo/local development)
+import { ZipMetadata, ZipKitMinter, ZipKitVerifier, ZipKitWallet, WalletAnalyzer } from '../src/blockchain';
+```
+
+### Unified NFT APIs (ZipKitNFT.ts)
+
+Prefer the unified entry point for minting and verification:
+
+```ts
+import { ZipKitNFT, ZipKitNFTMinter, ZipKitNFTVerifier } from 'neozipkit/blockchain';
+
+// Facade usage
+const nft = new ZipKitNFT({
+  archiveName: 'archive.zip',
+  merkleRoot: 'abc123...',
+  mintingOptions: { walletPrivateKey: '0x...', network: 'base-sepolia' },
+  verificationOptions: { debug: false }
+});
+
+// Or use classes directly
+const minter = new ZipKitNFTMinter('archive.zip', 'abc123...', { walletPrivateKey: '0x...', network: 'base-sepolia' });
+const verifier = new ZipKitNFTVerifier({ debug: false });
+```
+
+### OpenTimestamps (ZipKitOTS.ts)
+Bitcoin blockchain timestamping utilities for ZIP file integrity verification.
+
+#### Core Functions
+
+**Timestamp Creation & Verification:**
+- `createTimestamp(hashDigest: string, options?: { debug?: boolean }): Promise<Buffer | null>`
+  - Creates an OpenTimestamps proof for a hash digest. Submits hash to OpenTimestamps servers for Bitcoin blockchain anchoring.
+- `verifyOts(hashDigest: string | null, ots: ArrayBuffer | null, options?: { debug?: boolean }): Promise<TimestampResult | { error: string } | null>`
+  - Verifies an OpenTimestamps proof against a hash digest. Returns verification result, error object, or null if inputs invalid.
+- `verifyOtsZip(zip: any): Promise<OtsVerifyResult>`
+  - Verifies OpenTimestamps proof within a ZIP file. Extracts merkle root and OTS proof, then verifies against Bitcoin blockchain.
+
+**ZIP Integration:**
+- `getOtsEntry(zip: any): any | null`
+  - Finds the OpenTimestamps entry in a ZIP file. Searches for TIMESTAMP_METADATA first, then TIMESTAMP_SUBMITTED.
+- `getOtsBuffer(zip: any, otsEntry: any): Promise<Buffer | null>`
+  - Extracts OTS proof data from a ZIP entry.
+- `getMerkleRootSafe(zip: any): string | null`
+  - Safely extracts merkle root from a ZIP file.
+
+**Data Processing:**
+- `deserializeOts(tsResult: TimestampResult, options?: { debug?: boolean }): Promise<string | null>`
+  - Deserializes OpenTimestamps verification result into JSON format. Extracts blockchain attestation data and transaction details.
+- `parseVerifyResult(verifyResult: TimestampResult): Promise<TimestampInfo>`
+  - Parses timestamp verification result into readable information. Formats blockchain attestation data with human-readable messages and dates.
+
+**Certificate & Upgrade:**
+- `createCertificateOts(fileName: string, zipEntries: ZipEntry[], timestampResult: TimestampResult): Promise<string>`
+  - Creates an HTML certificate for OpenTimestamps verification. Generates a certificate file documenting the timestamp verification results.
+- `upgradeOTS(zipFilePath: string, upgradedOts: Buffer): Promise<void>`
+  - Upgrades OpenTimestamps proof in an existing ZIP file. Replaces old timestamp metadata with upgraded OTS proof data.
+- `createOtsMetadataEntry(zipKit: any, ots: Buffer | null): any | null`
+  - Creates a ZIP metadata entry containing OpenTimestamps proof. Creates a special ZIP entry marked as metadata that stores OTS proof data.
+
+**Utility Functions:**
+- `bufferToArrayBuffer(buf: Buffer): ArrayBuffer`
+  - Converts a Node.js Buffer to an ArrayBuffer.
+
+#### Types & Interfaces
+
+```typescript
+export interface TimestampResult {
+  merkleRoot: string | null;
+  ots: ArrayBuffer | null;
+  verified: boolean;
+  results: any | null;
+  error: string | null;
+  attestations: any | null;
+  upgradedOts: ArrayBuffer | null;
+}
+
+export interface TimestampInfo {
+  message: string;
+  results: string[];
+  attestDate: Date | null;
+  attestHeight: number | null;
+  submittedUri: string | null;
+  otsUpgraded: boolean;
+}
+
+export interface OtsVerifyResult {
+  status: 'none' | 'valid' | 'pending' | 'error';
+  message?: string;
+  blockHeight?: number;
+  attestedAt?: Date;
+  upgraded?: boolean;
+  upgradedOts?: Buffer;
+}
+
+export interface DeserializeOtsResult {
+  attestStr: string | null;
+  needsUpdateMsg: string | null;
+  attestationValues: any[];
+}
+```
+
+#### Usage Example
+
+```typescript
+import { createTimestamp, verifyOtsZip, upgradeOTS } from 'neozipkit/blockchain';
+
+// Create timestamp for a file's hash
+const otsProof = await createTimestamp(merkleRoot);
+
+// Verify a loaded ZIP file
+const result = await verifyOtsZip(zipInstance);
+if (result.status === 'valid') {
+  console.log(`Verified! Block: ${result.blockHeight}`);
+  
+  // Upgrade proof if available
+  if (result.upgradedOts) {
+    await upgradeOTS(zipPath, result.upgradedOts);
+  }
+}
+```
+
+### Contract Configuration (contracts.ts)
+All contract-related constants and configurations in one place:
+
+- `CONTRACT_CONFIGS`: Network configurations with contract addresses, RPC URLs, and explorer URLs
+- `NZIP_CONTRACT_ABI`: Full ABI for the NZIP‑NFT contract
+- `CURRENT_DEPLOYMENT`: Current default deployment (Base Sepolia)
+- `DEFAULT_NETWORK`: Default network chain ID (84532)
+- Helper functions: `getContractConfig()`, `getSupportedNetworks()`, `isNetworkSupported()`
+
+**Supported Networks**:
+- Base Sepolia (84532) - Primary testnet
+- Base Mainnet (8453) - Production
+
+### Token Verification (ZipKitVerifier.ts)
+- High-level verification API for NZIP‑NFT contract and on-chain checks.
+
+### Token Query (TokenQuerier.ts)
+- `queryBlockchainForExistingToken(merkleRoot: string, networkName: string): Promise<ExistingTokenInfo | null>`
+- `queryWalletTokens(address: string, networkName: string, options?: TokenQueryOptions): Promise<ExistingTokenInfo[]>`
+  - `TokenQueryOptions` include pagination/filters as implemented in the module.
+
+Re‑exports (index.ts):
+- `queryBlockchainForExistingToken`, `queryWalletTokens`, `ExistingTokenInfo`, `TokenQueryOptions`.
+
+### Wallet Manager (WalletManager.ts)
+- `class WalletManager`
+  - Handles provider, signer, and basic transaction flows for the library’s contract interactions.
+
+Re‑exports (index.ts):
+- `WalletManager`.
+
+### NFT Minting (ZipKitMinter.ts)
+- High‑level minting API for NZIP‑NFT contract.
+
+### Wallets (ZipKitWallet.ts)
+- `class ZipKitWallet`: Create/load/connect wallets and providers.
+- `class WalletAnalyzer`: Analyze balances, scan NZIP tokens, ERC‑20s and NFTs.
+- Types re‑exported: `TokenInfo`, `NZipTokenDetails`, `WalletBasicInfo`, `TokenScanResult`, `CommonTokenConfig`.
+
+  - Helpers to format token and wallet data for display.
+
+Re‑exports (index.ts):
+Wallet formatting helpers have been removed. Use your app's UI layer for presentation formatting.
+
+### ZIP Metadata Helpers (ZipMetadata.ts)
+- `class ZipMetadata`
+  - Validation and rendering helpers for token metadata embedded in ZIPs.
+
+Re‑exports (index.ts):
+- `ZipMetadata`.
+
+### Module Types (types.ts)
+Exports shared types used across blockchain operations, including:
+- `NZipTokenInfo`, `NZipTokenDetails`, `ZipFileInfo`, `WalletInfo`, `BlockchainVerification`, and others used by certificate/token helpers.
+
+### Notes
+- All OTS utilities suppress verbose logs by default. Pass `{ debug: true }` to see OpenTimestamps logs.
+- Contract addresses vary per network; see `CONTRACT_ADDRESSES` and keep them updated after deployments.
+

package/src/blockchain/ZipKitMinter.ts

@@ -0,0 +1,470 @@
+#!/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

@@ -0,0 +1,12 @@
+// 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';