neozipkit 0.1.1

package/dist/server/blockchain/NFTMinter.js

@@ -0,0 +1,323 @@
+"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;

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

@@ -0,0 +1,31 @@
+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 declare function queryBlockchainForExistingToken(merkleRoot: string, fileName: string, options?: TokenQueryOptions): Promise<ExistingTokenInfo | 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 declare function queryWalletTokens(walletAddress: string, options?: TokenQueryOptions): Promise<ExistingTokenInfo[]>;

package/dist/server/blockchain/TokenQuerier.js

@@ -0,0 +1,259 @@
+"use strict";
+// ======================================
+//	TokenQuerier.ts
+//  Blockchain token querying 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.queryBlockchainForExistingToken = queryBlockchainForExistingToken;
+exports.queryWalletTokens = queryWalletTokens;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+// Network configuration for blockchain queries
+const NETWORK_CONFIG = {
+    '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: constants_1.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
+    }
+};
+/**
+ * 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
+ */
+async function queryBlockchainForExistingToken(merkleRoot, fileName, options = {}) {
+    try {
+        const { ethers } = await Promise.resolve().then(() => __importStar(require('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 = {
+                                    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 = {
+                                        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
+ */
+async function queryWalletTokens(walletAddress, options = {}) {
+    try {
+        const { ethers } = await Promise.resolve().then(() => __importStar(require('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 = [];
+        // 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 = {
+                            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 [];
+    }
+}

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

@@ -0,0 +1,20 @@
+import ZipKitServer from '../platform/server/ZipKitServer';
+import { NZipTokenInfo } from './types';
+export interface TokenVerificationOptions {
+    skipHash?: boolean;
+    skipToken?: boolean;
+    generateCertificate?: boolean;
+    zipFileName?: string;
+}
+export interface TokenVerificationResult {
+    isTokenized: boolean;
+    tokenMetadata: NZipTokenInfo | null;
+    calculatedMerkleRoot: string | null;
+    blockchainMerkleRoot: string | null;
+    verificationPassed: boolean;
+    certificatePath?: string;
+}
+/**
+ * Checks if the ZIP file contains NFT token metadata and verifies the merkle root
+ */
+export declare function checkForTokenization(zipKit: ZipKitServer, options?: TokenVerificationOptions): Promise<TokenVerificationResult>;