neozipkit 0.1.1 → 0.2.1

package/dist/browser/TokenVerifierBrowser.js

@@ -1,299 +0,0 @@
-"use strict";
-// ======================================
-//	TokenVerifierBrowser.ts
-//  Browser-compatible blockchain token verification utilities for ZIP archives
-//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
-// ======================================
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenVerifierBrowser = void 0;
-exports.createTokenVerifier = createTokenVerifier;
-exports.checkForTokenization = checkForTokenization;
-const Headers_1 = require("../shared/constants/Headers");
-const constants_1 = require("../server/blockchain/constants");
-// Network configuration for blockchain queries
-const NETWORK_CONFIG = {
-    'Base Sepolia': {
-        chainId: 84532,
-        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'
-        ]
-    },
-    'Base Mainnet': {
-        chainId: 8453,
-        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'
-        ]
-    }
-};
-// Use the complete contract ABI from constants
-const CONTRACT_ABI = constants_1.NZIP_CONTRACT_ABI;
-/**
- * Browser-compatible token verification class
- */
-class TokenVerifierBrowser {
-    constructor(zipKit) {
-        this.zipKit = zipKit;
-    }
-    /**
-     * Checks if the ZIP file contains NFT token metadata and verifies the merkle root
-     */
-    async checkForTokenization(zipEntries, options = {}) {
-        // Look for the tokenized metadata file
-        const tokenEntry = zipEntries.find(entry => entry.filename === Headers_1.TOKENIZED_METADATA);
-        if (!tokenEntry) {
-            return {
-                isTokenized: false,
-                tokenMetadata: null,
-                calculatedMerkleRoot: null,
-                blockchainMerkleRoot: null,
-                verificationPassed: false
-            };
-        }
-        try {
-            // Extract the token metadata
-            const tokenData = await this.zipKit.extractBlob(tokenEntry);
-            if (!tokenData) {
-                return {
-                    isTokenized: false,
-                    tokenMetadata: null,
-                    calculatedMerkleRoot: null,
-                    blockchainMerkleRoot: null,
-                    verificationPassed: false,
-                    errorMessage: 'Could not read token metadata'
-                };
-            }
-            const tokenContent = await this.blobToString(tokenData);
-            const tokenMetadata = JSON.parse(tokenContent);
-            // Validate token metadata structure
-            if (!this.validateTokenInfo(tokenMetadata)) {
-                return {
-                    isTokenized: false,
-                    tokenMetadata: null,
-                    calculatedMerkleRoot: null,
-                    blockchainMerkleRoot: null,
-                    verificationPassed: false,
-                    errorMessage: 'Invalid token metadata structure'
-                };
-            }
-            // Skip verification if requested
-            if (options.skipHash || options.skipToken) {
-                return {
-                    isTokenized: true,
-                    tokenMetadata,
-                    calculatedMerkleRoot: null,
-                    blockchainMerkleRoot: null,
-                    verificationPassed: false,
-                    errorMessage: options.skipHash ? 'Hash verification skipped' : 'Token verification skipped'
-                };
-            }
-            // Calculate merkle root excluding token file
-            const calculatedMerkleRoot = await this.calculateMerkleRootExcludingToken(zipEntries);
-            if (!calculatedMerkleRoot) {
-                return {
-                    isTokenized: true,
-                    tokenMetadata,
-                    calculatedMerkleRoot: null,
-                    blockchainMerkleRoot: null,
-                    verificationPassed: false,
-                    errorMessage: 'Could not calculate merkle root'
-                };
-            }
-            // Query blockchain for the actual merkle root and timestamp
-            const blockchainData = await this.queryBlockchainData(tokenMetadata);
-            if (!blockchainData.merkleRoot) {
-                return {
-                    isTokenized: true,
-                    tokenMetadata,
-                    calculatedMerkleRoot,
-                    blockchainMerkleRoot: null,
-                    blockchainTimestamp: blockchainData.timestamp ?? undefined,
-                    verificationPassed: false,
-                    errorMessage: 'Could not retrieve merkle root from blockchain'
-                };
-            }
-            const verificationPassed = blockchainData.merkleRoot === calculatedMerkleRoot;
-            return {
-                isTokenized: true,
-                tokenMetadata,
-                calculatedMerkleRoot,
-                blockchainMerkleRoot: blockchainData.merkleRoot,
-                blockchainTimestamp: blockchainData.timestamp ?? undefined,
-                verificationPassed,
-                errorMessage: verificationPassed ? undefined : 'Merkle root mismatch - archive may be tampered'
-            };
-        }
-        catch (error) {
-            return {
-                isTokenized: false,
-                tokenMetadata: null,
-                calculatedMerkleRoot: null,
-                blockchainMerkleRoot: null,
-                verificationPassed: false,
-                errorMessage: `Error processing token: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    /**
-     * Validates token metadata structure
-     */
-    validateTokenInfo(tokenMetadata) {
-        return tokenMetadata &&
-            typeof tokenMetadata.version === 'string' &&
-            typeof tokenMetadata.tokenId === 'string' &&
-            typeof tokenMetadata.contractAddress === 'string' &&
-            typeof tokenMetadata.network === 'string' &&
-            typeof tokenMetadata.networkChainId === 'number' &&
-            typeof tokenMetadata.transactionHash === 'string' &&
-            typeof tokenMetadata.merkleRoot === 'string' &&
-            typeof tokenMetadata.fileName === 'string' &&
-            typeof tokenMetadata.mintedAt === 'string';
-    }
-    /**
-     * Calculates the merkle root excluding the token metadata file
-     */
-    async calculateMerkleRootExcludingToken(zipEntries) {
-        try {
-            // Get all entries except the token file
-            const contentEntries = zipEntries.filter(entry => entry.filename !== Headers_1.TOKENIZED_METADATA);
-            if (contentEntries.length === 0) {
-                return null;
-            }
-            // For each content entry, ensure we have SHA-256 hash calculated
-            for (const entry of contentEntries) {
-                if (!entry.sha256) {
-                    // Extract the file to calculate its SHA-256 hash
-                    await this.zipKit.extractBlob(entry);
-                }
-            }
-            // Calculate merkle root from content files
-            // This would need to be implemented based on the ZipKit's merkle tree functionality
-            // For now, we'll use a placeholder that would need to be implemented
-            return await this.zipKit.getMerkleRoot?.() || null;
-        }
-        catch (error) {
-            console.error('Error calculating merkle root:', error);
-            return null;
-        }
-    }
-    /**
-     * Queries the blockchain to get the actual merkle root and timestamp stored in the smart contract
-     */
-    async queryBlockchainData(tokenMetadata) {
-        try {
-            // Dynamic import of ethers to avoid SSR issues
-            const { ethers } = await Promise.resolve().then(() => __importStar(require('ethers')));
-            const networkConfig = NETWORK_CONFIG[tokenMetadata.network];
-            if (!networkConfig) {
-                console.warn(`Unsupported network: ${tokenMetadata.network}`);
-                return { merkleRoot: null, timestamp: null };
-            }
-            // Try multiple RPC endpoints
-            for (const rpcUrl of networkConfig.rpcUrls) {
-                try {
-                    const provider = new ethers.JsonRpcProvider(rpcUrl);
-                    // Test connection with a timeout
-                    const blockNumber = await Promise.race([
-                        provider.getBlockNumber(),
-                        new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 5000))
-                    ]);
-                    // Create contract instance
-                    const contract = new ethers.Contract(tokenMetadata.contractAddress, CONTRACT_ABI, provider);
-                    // Call getZipFileInfo to get the blockchain-stored data
-                    const zipInfo = await contract.getZipFileInfo(tokenMetadata.tokenId);
-                    return {
-                        merkleRoot: zipInfo.merkleRootHash,
-                        timestamp: Number(zipInfo.tokenizationTime)
-                    };
-                }
-                catch (error) {
-                    console.warn(`RPC ${rpcUrl} failed:`, error);
-                    continue;
-                }
-            }
-            console.warn(`All RPC endpoints failed for network: ${tokenMetadata.network}`);
-            return { merkleRoot: null, timestamp: null };
-        }
-        catch (error) {
-            console.error('Blockchain query error:', error);
-            return { merkleRoot: null, timestamp: null };
-        }
-    }
-    /**
-     * Helper to convert Blob to string
-     */
-    async blobToString(blob) {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onload = () => resolve(reader.result);
-            reader.onerror = reject;
-            reader.readAsText(blob);
-        });
-    }
-    /**
-     * Creates a formatted summary of token information
-     */
-    createTokenSummary(tokenMetadata) {
-        return `
-🎫 NFT Token Information:
-   Token ID: ${tokenMetadata.tokenId}
-   Network: ${tokenMetadata.network}
-   Contract: ${tokenMetadata.contractAddress}
-   Transaction: ${tokenMetadata.transactionHash}
-   File: ${tokenMetadata.fileName}
-   Minted: ${new Date(tokenMetadata.mintedAt).toLocaleString()}
-   `;
-    }
-}
-exports.TokenVerifierBrowser = TokenVerifierBrowser;
-/**
- * Creates a new TokenVerifierBrowser instance
- */
-function createTokenVerifier(zipKit) {
-    return new TokenVerifierBrowser(zipKit);
-}
-/**
- * Convenience function to check for tokenization
- */
-async function checkForTokenization(zipKit, zipEntries, options = {}) {
-    const verifier = new TokenVerifierBrowser(zipKit);
-    return verifier.checkForTokenization(zipEntries, options);
-}

package/dist/server/blockchain/NFTMinter.d.ts

@@ -1,41 +0,0 @@
-import { ethers } from 'ethers';
-import { MintingResult, ZipTokenData, NFTMetadata } from './types';
-export interface ExistingTokenInfo {
-    tokenId: string;
-    fileName: string;
-    merkleRootHash: string;
-    creationTimestamp: number;
-    tokenizationTime: number;
-    creator: string;
-    isOwnedByWallet: boolean;
-}
-export declare class NFTMinter {
-    private wallet;
-    private provider;
-    constructor(wallet: ethers.Wallet | null, provider: ethers.JsonRpcProvider | null);
-    /**
-     * Creates NFT metadata for the ZIP archive
-     */
-    createNFTMetadata(zipTokenData: ZipTokenData): NFTMetadata;
-    /**
-     * Loads contract deployment information
-     */
-    private loadContractInfo;
-    /**
-     * Check for existing tokens with the same merkle root
-     * This is efficient because it uses the contract's getTokensByMerkleRoot function
-     */
-    findExistingTokensByMerkleRoot(merkleRoot: string): Promise<ExistingTokenInfo[]>;
-    /**
-     * Prompts user to choose between reusing an existing timestamp or creating a new token
-     */
-    promptUserChoice(existingTokens: ExistingTokenInfo[], fileName: string): Promise<{
-        useExisting: boolean;
-        selectedTimestamp?: number;
-        selectedTokenId?: string;
-    }>;
-    /**
-     * Mints an NFT token for the ZIP archive using the timestamped contract
-     */
-    mintZipFileNFT(zipTokenData: ZipTokenData): Promise<MintingResult>;
-}

package/dist/server/blockchain/NFTMinter.js

@@ -1,323 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NFTMinter = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const ethers_1 = require("ethers");
-const types_1 = require("./types");
-class NFTMinter {
-    constructor(wallet, provider) {
-        this.wallet = wallet;
-        this.provider = provider;
-    }
-    /**
-     * Creates NFT metadata for the ZIP archive
-     */
-    createNFTMetadata(zipTokenData) {
-        const metadata = { ...types_1.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
-     */
-    loadContractInfo() {
-        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;
-        }
-        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) {
-        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_1.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 = [];
-            for (const tokenId of tokenIds) {
-                try {
-                    // Get token info
-                    const zipInfo = await contract.getZipFileInfo(tokenId);
-                    const owner = await contract.ownerOf(tokenId);
-                    const tokenInfo = {
-                        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, fileName) {
-        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) => {
-                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) {
-        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;
-            let reusingExistingToken = false;
-            let selectedTokenId;
-            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_1.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_1.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;
-                for (const log of receipt.logs) {
-                    try {
-                        const parsedLog = contract.interface.parseLog(log);
-                        if (parsedLog && parsedLog.name === 'Transfer' && parsedLog.args.from === ethers_1.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) {
-                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) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`Error minting NFT: ${errorMessage}`);
-            return {
-                success: false,
-                message: `Error minting NFT: ${errorMessage}`
-            };
-        }
-    }
-}
-exports.NFTMinter = NFTMinter;