neozip-cli 0.75.2-beta → 0.90.0

package/dist/src/neozip/createZip.js

@@ -46,11 +46,14 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const neozipkit_1 = require("neozipkit");
 const node_1 = __importDefault(require("neozipkit/node"));
-const blockchain_1 = require("neozipkit/blockchain");
+const neozip_blockchain_1 = require("neozip-blockchain");
+const ots_1 = require("neozip-blockchain/ots");
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
 const CommentManager_1 = require("./CommentManager");
 const utils_1 = require("./utils");
 const file_operations_1 = require("./file-operations");
-const blockchain_2 = require("./blockchain");
+const blockchain_1 = require("./blockchain");
+const ConfigStore_1 = require("../config/ConfigStore");
 const user_interaction_1 = require("./user-interaction");
 const exit_codes_1 = require("../exit-codes");
 const version_1 = require("../version");
@@ -254,7 +257,7 @@ class ZipCreator {
         this.centralDirOffset = 0;
         this.zip = new node_1.default(); // Use ZipkitNode for ZIP operations
         // Initialize HashAccumulator if blockchain features are enabled
-        if (this.options.blockchain || this.options.blockchainOts) {
+        if (this.options.blockchain || this.options.blockchainOts || this.options.blockchainZipstamp) {
             this.hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
         }
     }
@@ -284,7 +287,7 @@ class ZipCreator {
      */
     async writeChunk(data) {
         // For in-memory non-blockchain mode, write to buffer
-        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts) {
+        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts && !this.options.blockchainZipstamp) {
             const bufferWriter = this.zip.bufferWriter;
             if (bufferWriter) {
                 // Determine if this is a header or data by checking signature
@@ -333,7 +336,7 @@ class ZipCreator {
             // Initialize output stream for file-based mode OR in-memory blockchain mode
             // For in-memory blockchain mode, we need to write directly to file during compression
             // For in-memory non-blockchain mode, output is written directly during compression
-            if (!this.options.inMemory || (this.options.blockchain || this.options.blockchainOts)) {
+            if (!this.options.inMemory || (this.options.blockchain || this.options.blockchainOts || this.options.blockchainZipstamp)) {
                 await this.initializeOutput();
             }
             await this.processFiles();
@@ -401,9 +404,12 @@ class ZipCreator {
         const compressionDesc = this.options.level === 0 ? 'store (no compression)' : `${this.options.compression} (level ${this.options.level})`;
         (0, utils_1.log)(`🔧 Compression: ${compressionDesc}`, this.options);
         (0, utils_1.log)(`📊 Block size: ${(0, utils_1.formatBytes)(this.options.blockSize || 64 * 1024)}`, this.options);
-        (0, utils_1.log)(`🔗 Tokenization: ${this.options.blockchain ? 'enabled' : 'disabled'}`, this.options);
-        const encryptionMethod = this.options.encryptionMethod || 'pkzip';
-        (0, utils_1.log)(`🔐 Encryption: ${this.options.encrypt ? `${encryptionMethod.toUpperCase()} enabled` : 'disabled'}`, this.options);
+        if (!this.options.blockchainZipstamp && !this.options.blockchainOts) {
+            (0, utils_1.log)(`🔗 Tokenization: ${this.options.blockchain ? 'enabled' : 'disabled'}`, this.options);
+        }
+        const encryptionMethod = this.options.encryptionMethod || 'aes256';
+        const encryptionLabel = encryptionMethod === 'aes256' ? 'AES-256' : 'PKZIP';
+        (0, utils_1.log)(`🔐 Encryption: ${this.options.encrypt ? `${encryptionLabel} enabled` : 'disabled'}`, this.options);
         (0, utils_1.log)('', this.options);
         if (this.options.debug) {
             (0, utils_1.logDebug)('Debug mode enabled', this.options);
@@ -433,6 +439,10 @@ class ZipCreator {
                 (0, utils_1.log)(`Blockchain: enabled (OpenTimestamp)`, this.options);
                 (0, utils_1.log)(`Bitcoin blockchain: enabled`, this.options);
             }
+            else if (this.options.blockchainZipstamp) {
+                (0, utils_1.log)(`Blockchain: enabled (Zipstamp)`, this.options);
+                (0, utils_1.log)(`Zipstamp: enabled`, this.options);
+            }
             else {
                 (0, utils_1.log)(`Blockchain: disabled`, this.options);
                 (0, utils_1.log)(`Tokenization: disabled`, this.options);
@@ -811,9 +821,9 @@ class ZipCreator {
         const compressionOptions = {
             level: level,
             useZstd: level === 0 ? false : (this.options.compression || 'zstd') === 'zstd',
-            useSHA256: this.options.blockchain || this.options.blockchainOts || false,
+            useSHA256: this.options.blockchain || this.options.blockchainOts || this.options.blockchainZipstamp || false,
             password: this.options.encrypt ? this.options.password : null,
-            encryptionMethod: this.options.encryptionMethod || 'pkzip'
+            encryptionMethod: (this.options.encryptionMethod === 'pkzip' ? 'zipcrypto' : 'aes256')
         };
         // Get entries from zip.getDirectory() (populated by processFiles())
         // This is the single source of truth for entry order
@@ -829,7 +839,7 @@ class ZipCreator {
             // Create ZipkitNode instance for buffer-based compression
             const zipkit = new node_1.default();
             // Determine if we need to write to file (for blockchain mode)
-            const writeToFile = this.options.blockchain || this.options.blockchainOts;
+            const writeToFile = this.options.blockchain || this.options.blockchainOts || this.options.blockchainZipstamp;
             // Create appropriate output writer
             let writer;
             const positionRef = { current: this.currentPosition };
@@ -911,9 +921,11 @@ class ZipCreator {
                     if (this.hashAccumulator && entry.sha256) {
                         const filename = entry.filename || '';
                         // Skip blockchain metadata files
-                        if (filename !== neozipkit_1.TOKENIZED_METADATA &&
-                            filename !== neozipkit_1.TIMESTAMP_METADATA &&
-                            filename !== neozipkit_1.TIMESTAMP_SUBMITTED) {
+                        if (filename !== neozip_blockchain_1.TOKENIZED_METADATA &&
+                            filename !== ots_1.TIMESTAMP_METADATA &&
+                            filename !== ots_1.TIMESTAMP_SUBMITTED &&
+                            filename !== zipstamp_server_1.SUBMIT_METADATA &&
+                            filename !== zipstamp_server_1.TIMESTAMP_METADATA) {
                             const hashBuffer = Buffer.from(entry.sha256, 'hex');
                             this.hashAccumulator.addHash(hashBuffer);
                             if (this.options.verbose) {
@@ -978,9 +990,11 @@ class ZipCreator {
                 for (let index = 0; index < entryCnt; index++) {
                     const entry = zipEntries[index];
                     // Filter out metadata entries (handled separately in handleTokenization)
-                    if (entry.filename === neozipkit_1.TOKENIZED_METADATA ||
-                        entry.filename === neozipkit_1.TIMESTAMP_METADATA ||
-                        entry.filename === neozipkit_1.TIMESTAMP_SUBMITTED) {
+                    if (entry.filename === neozip_blockchain_1.TOKENIZED_METADATA ||
+                        entry.filename === ots_1.TIMESTAMP_METADATA ||
+                        entry.filename === ots_1.TIMESTAMP_SUBMITTED ||
+                        entry.filename === zipstamp_server_1.SUBMIT_METADATA ||
+                        entry.filename === zipstamp_server_1.TIMESTAMP_METADATA) {
                         zipEntries.splice(index, 1);
                         entryCnt--;
                         index--;
@@ -1059,9 +1073,11 @@ class ZipCreator {
                                 if (this.hashAccumulator) {
                                     const filename = entry.filename || '';
                                     // Skip blockchain metadata files
-                                    if (filename !== neozipkit_1.TOKENIZED_METADATA &&
-                                        filename !== neozipkit_1.TIMESTAMP_METADATA &&
-                                        filename !== neozipkit_1.TIMESTAMP_SUBMITTED) {
+                                    if (filename !== neozip_blockchain_1.TOKENIZED_METADATA &&
+                                        filename !== ots_1.TIMESTAMP_METADATA &&
+                                        filename !== ots_1.TIMESTAMP_SUBMITTED &&
+                                        filename !== zipstamp_server_1.SUBMIT_METADATA &&
+                                        filename !== zipstamp_server_1.TIMESTAMP_METADATA) {
                                         this.hashAccumulator.addHash(hash);
                                         if (this.options.verbose) {
                                             (0, utils_1.logDebug)(`Added SHA-256 hash to accumulator for ${filename}`, this.options);
@@ -1139,9 +1155,11 @@ class ZipCreator {
         // Filter out blockchain metadata files to ensure consistent Merkle Root calculation
         const contentEntries = entries.filter(entry => {
             const filename = entry.filename || '';
-            return filename !== neozipkit_1.TOKENIZED_METADATA &&
-                filename !== neozipkit_1.TIMESTAMP_METADATA &&
-                filename !== neozipkit_1.TIMESTAMP_SUBMITTED;
+            return filename !== neozip_blockchain_1.TOKENIZED_METADATA &&
+                filename !== ots_1.TIMESTAMP_METADATA &&
+                filename !== ots_1.TIMESTAMP_SUBMITTED &&
+                filename !== zipstamp_server_1.SUBMIT_METADATA &&
+                filename !== zipstamp_server_1.TIMESTAMP_METADATA;
         });
         // Add SHA-256 hashes to accumulator
         for (const entry of contentEntries) {
@@ -1158,12 +1176,13 @@ class ZipCreator {
         let tokenMeta = null;
         let tokenInfoEntry = null;
         let otsMetaEntry = null;
+        let zipstampMetaEntry = null;
         let merkleRoot = null;
         if (this.options.blockchain) {
             // Check for wallet passkey AFTER compression is complete
             // Priority: -w option > wallet.json > environment variable
             // Don't show error yet - we'll prompt user if key is missing
-            const walletPasskey = (0, blockchain_2.getWalletPasskey)(this.options.walletKey, false);
+            const walletPasskey = (0, blockchain_1.getWalletPasskey)(this.options.walletKey, false);
             if (!walletPasskey) {
                 // Show error message and prompt user
                 console.error('\n❌ Error: Wallet private key is required for blockchain operations');
@@ -1186,6 +1205,7 @@ class ZipCreator {
                         (0, utils_1.log)('⚠️  Continuing without blockchain tokenization (ZIP file is already created)...', this.options);
                         this.options.blockchain = false;
                         this.options.blockchainOts = false;
+                        this.options.blockchainZipstamp = false;
                         return; // Skip tokenization, ZIP is already complete
                     }
                     else {
@@ -1276,7 +1296,7 @@ class ZipCreator {
                 // Always display network when tokenization is enabled
                 console.log(`🌐 Network: ${network}`);
                 // Get network config for contract address and version info
-                const networkConfig = (0, blockchain_1.getNetworkByName)(network);
+                const networkConfig = (0, neozip_blockchain_1.getNetworkByName)(network);
                 let contractAddress;
                 let networkChainId;
                 let contractVersion;
@@ -1290,7 +1310,7 @@ class ZipCreator {
                 }
                 else {
                     // Fallback to default (Base Sepolia)
-                    const defaultConfig = (0, blockchain_1.getContractConfig)(84532);
+                    const defaultConfig = (0, neozip_blockchain_1.getContractConfig)(84532);
                     contractAddress = defaultConfig.address;
                     networkChainId = defaultConfig.chainId;
                     const versionStr = defaultConfig.version || '0';
@@ -1300,8 +1320,8 @@ class ZipCreator {
                 // Display contract address and version right after network
                 console.log(`📄 Contract: ${contractAddress}`);
                 console.log(`🔢 Version: ${contractVersion}`);
-                if (!(0, blockchain_2.isSupportedNetwork)(network)) {
-                    const supportedNetworks = (0, blockchain_1.getSupportedNetworkNames)();
+                if (!(0, blockchain_1.isSupportedNetwork)(network)) {
+                    const supportedNetworks = (0, neozip_blockchain_1.getSupportedNetworkNames)();
                     console.error(`❌ Error: Unsupported network: ${network}`);
                     console.error(`   Currently supported networks: ${supportedNetworks.join(', ')}`);
                     (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR);
@@ -1309,7 +1329,7 @@ class ZipCreator {
                 let minter = null;
                 try {
                     // Initialize blockchain minter
-                    minter = new neozipkit_1.ZipkitMinter(merkleRoot, {
+                    minter = new neozip_blockchain_1.ZipkitMinter(merkleRoot, {
                         network: network,
                         walletPrivateKey: this.options.walletPasskey,
                         verbose: this.options.verbose,
@@ -1380,7 +1400,7 @@ class ZipCreator {
                         }
                         else if (userChoice.action === 'mint-new') {
                             // Mint new token
-                            const mintResult = await (0, blockchain_2.handleTokenMinting)(minter, this.zip, this.options.nonInteractive || false, 0);
+                            const mintResult = await (0, blockchain_1.handleTokenMinting)(minter, this.zip, this.options.nonInteractive || false, 0);
                             if (mintResult.success && mintResult.tokenInfo) {
                                 tokenMeta = mintResult.tokenInfo;
                                 // Add token metadata directly to ZIP (after compression, at the end)
@@ -1417,7 +1437,7 @@ class ZipCreator {
                     }
                     else {
                         // No existing tokens, mint new one
-                        const mintResult = await (0, blockchain_2.handleTokenMinting)(minter, this.zip, this.options.nonInteractive || false, 0);
+                        const mintResult = await (0, blockchain_1.handleTokenMinting)(minter, this.zip, this.options.nonInteractive || false, 0);
                         if (mintResult.success && mintResult.tokenInfo) {
                             tokenMeta = mintResult.tokenInfo;
                             // Add token metadata directly to ZIP (after compression, at the end)
@@ -1537,16 +1557,16 @@ class ZipCreator {
                 console.log(`📋 Merkle Root: ${merkleRoot}`);
                 // Create actual OpenTimestamp proof
                 try {
-                    const otsProof = await (0, neozipkit_1.createTimestamp)(merkleRoot, { debug: this.options.verbose });
+                    const otsProof = await (0, ots_1.createTimestamp)(merkleRoot, { debug: this.options.verbose });
                     if (!otsProof) {
                         throw new Error('Failed to create OpenTimestamp proof');
                     }
                     console.log('📄 OpenTimestamp metadata prepared');
                     // Use the createOtsMetadataEntry function like in the example
-                    const metaEntry = (0, blockchain_1.createOtsMetadataEntry)(this.zip, otsProof);
+                    const metaEntry = (0, ots_1.createOtsMetadataEntry)(this.zip, otsProof);
                     if (metaEntry) {
                         // Ensure the filename is set correctly
-                        metaEntry.filename = neozipkit_1.TIMESTAMP_SUBMITTED;
+                        metaEntry.filename = ots_1.TIMESTAMP_SUBMITTED;
                         // Ensure OTS entry uses STORED compression (no compression for small metadata file)
                         metaEntry.cmpMethod = 0; // STORED
                         metaEntry.compressedSize = metaEntry.fileBuffer?.length || metaEntry.uncompressedSize || 0;
@@ -1586,10 +1606,143 @@ class ZipCreator {
                 }
             }
         }
+        else if (this.options.blockchainZipstamp) {
+            // Handle Zipstamp timestamp for blockchain
+            if (this.options.debug) {
+                (0, utils_1.logDebug)('Zipstamp process starting...', this.options);
+            }
+            console.log('🔗 Zipstamp: Creating timestamp proof on blockchain...');
+            // Calculate merkle root (reuse same logic as OTS)
+            let merkleRoot = null;
+            if (this.hashAccumulator && this.hashAccumulator.leafCount() > 0) {
+                merkleRoot = this.hashAccumulator.merkleRoot();
+                if (this.options.verbose) {
+                    console.log(`✅ Calculated merkle root from ${this.hashAccumulator.leafCount()} accumulated SHA-256 hashes`);
+                }
+            }
+            else {
+                let entriesForMerkle = [];
+                const zipEntries = this.zip.getDirectory();
+                if (zipEntries.length > 0) {
+                    entriesForMerkle = zipEntries;
+                }
+                else {
+                    try {
+                        if (fs.existsSync(this.archiveName)) {
+                            const zipkit = new node_1.default();
+                            if (this.options.inMemory) {
+                                const zipBuffer = fs.readFileSync(this.archiveName);
+                                zipkit.loadZip(zipBuffer);
+                            }
+                            else {
+                                await zipkit.loadZipFile(this.archiveName);
+                            }
+                            entriesForMerkle = zipkit.getDirectory() || [];
+                        }
+                        else {
+                            entriesForMerkle = await this.zip.getDirectory() || [];
+                        }
+                    }
+                    catch (error) {
+                        console.error('❌ Error loading ZIP file for merkle root calculation:', error instanceof Error ? error.message : String(error));
+                        entriesForMerkle = await this.zip.getDirectory() || [];
+                    }
+                }
+                merkleRoot = this.calculateMerkleRootFromEntries(entriesForMerkle);
+            }
+            if (!merkleRoot) {
+                console.error('❌ Error calculating merkle root for Zipstamp');
+                console.error('   Make sure files have been compressed with SHA-256 hashes.');
+                if (this.options.verbose) {
+                    const hashCount = this.hashAccumulator ? this.hashAccumulator.leafCount() : 0;
+                    console.error(`   Found ${hashCount} accumulated SHA-256 hashes`);
+                }
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+            }
+            if (this.options.verbose && this.hashAccumulator) {
+                console.log(`✅ Calculated merkle root from ${this.hashAccumulator.leafCount()} accumulated SHA-256 hashes`);
+            }
+            if (merkleRoot) {
+                console.log(`📋 Merkle Root: ${merkleRoot}`);
+                const recipientEmail = this.options.timestampEmail ||
+                    process.env.NEOZIP_TIMESTAMP_EMAIL ||
+                    ConfigStore_1.ConfigStore.getConfig().timestampEmail;
+                console.log('🔗 Submitting hash digest to ZipStamp server...');
+                console.log(`   Zipstamp Server: ${(0, zipstamp_server_1.getZipStampServerUrl)()}`);
+                console.log(`📧 Email: ${recipientEmail || '(none set)'}`);
+                try {
+                    const zipstampMetadata = await (0, zipstamp_server_1.createTimestamp)(merkleRoot, {
+                        recipientEmail: recipientEmail || undefined,
+                        debug: this.options.verbose
+                    });
+                    if (!zipstampMetadata) {
+                        throw new Error('Failed to create Zipstamp timestamp');
+                    }
+                    console.log('📄 Zipstamp metadata prepared');
+                    const metaEntry = (0, zipstamp_server_1.createTimestampMetadataEntry)(this.zip, zipstampMetadata);
+                    if (metaEntry) {
+                        // createTimestampMetadataEntry sets filename based on status (TS-SUBMIT.NZIP or TIMESTAMP.NZIP)
+                        metaEntry.cmpMethod = 0; // STORED
+                        metaEntry.compressedSize = metaEntry.fileBuffer?.length || metaEntry.uncompressedSize || 0;
+                        if (this.options.verbose) {
+                            console.log(`📂 Final timestamp entry: ${metaEntry.filename}`);
+                            console.log(`📏 Final timestamp entry size: ${metaEntry.fileBuffer?.length || metaEntry.uncompressedSize || 0} bytes`);
+                        }
+                        console.log('✅ Zipstamp proof created and queued for inclusion');
+                        const isConfirmed = (metaEntry.filename || '').includes('TIMESTAMP') && !(metaEntry.filename || '').includes('TS-SUBMIT');
+                        console.log(isConfirmed
+                            ? '   Timestamp proof is recorded on the blockchain.'
+                            : '   Timestamp proof will be recorded on the blockchain once confirmed.');
+                        metaEntry.localHdrOffset = this.currentPosition;
+                        if (this.zipWriter) {
+                            this.zipWriter.entryPositions.set(metaEntry.filename, this.currentPosition);
+                        }
+                        const localHdr = metaEntry.createLocalHdr();
+                        if (this.options.verbose) {
+                            (0, utils_1.log)(`📝 Writing Zipstamp entry: ${metaEntry.filename} at offset ${this.currentPosition}`, this.options);
+                            (0, utils_1.log)(`📊 Zipstamp entry size: ${metaEntry.fileBuffer?.length || 0} bytes`, this.options);
+                        }
+                        await this.writeChunk(localHdr);
+                        if (metaEntry.fileBuffer) {
+                            await this.writeChunk(metaEntry.fileBuffer);
+                        }
+                        zipstampMetaEntry = metaEntry;
+                    }
+                    else {
+                        console.warn('⚠️  Warning: Failed to create Zipstamp metadata entry');
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    console.error('❌ Failed to create Zipstamp proof:', errorMessage);
+                    const isValidationOrEmailError = errorMessage.toLowerCase().includes('validation') ||
+                        errorMessage.toLowerCase().includes('email') ||
+                        errorMessage.toLowerCase().includes('verify');
+                    if (isValidationOrEmailError) {
+                        console.error('');
+                        if (recipientEmail) {
+                            console.error(`   Email used: ${recipientEmail}`);
+                            console.error('');
+                        }
+                        else {
+                            console.error('   No email was set (use --timestamp-email, NEOZIP_TIMESTAMP_EMAIL, or neozip verify-email).');
+                            console.error('');
+                        }
+                        console.error('💡 Zipstamp requires a verified email. Run:');
+                        console.error('   neozip verify-email');
+                        console.error('');
+                        console.error('   Or use: --timestamp-email <your-verified-email>');
+                        console.error('   Or set: NEOZIP_TIMESTAMP_EMAIL environment variable');
+                        console.error('');
+                    }
+                    throw error;
+                }
+            }
+        }
     }
     async finalize() {
         // Check if this is in-memory non-blockchain mode (needs special handling)
-        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts) {
+        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts && !this.options.blockchainZipstamp) {
             // For in-memory non-blockchain mode, write complete ZIP file from buffer
             // Metadata should already be in the buffer (added via writeChunk() in handleTokenization())
             const bufferWriter = this.zip.bufferWriter;
@@ -1752,6 +1905,9 @@ async function testArchiveIntegrity(archiveName, options) {
     try {
         // Always show when integrity testing starts
         (0, utils_1.log)(`\n🧪 Testing archive integrity: ${archiveName}`, options);
+        if (options.blockchainZipstamp) {
+            (0, utils_1.log)(`   (Validating file integrity only; timestamp not yet confirmed on blockchain)`, options);
+        }
         // Import child_process for shelling out
         const { spawn } = require('child_process');
         // Use the installed neounzip command directly (works in both dev and installed)
@@ -1760,6 +1916,11 @@ async function testArchiveIntegrity(archiveName, options) {
         return new Promise((resolve) => {
             // Build neounzip command arguments
             const args = ['-t'];
+            // For Zipstamp timestamped files: skip blockchain verification during integrity test.
+            // We only validate file integrity (SHA-256); timestamp is pending and not yet minted.
+            if (options.blockchainZipstamp) {
+                args.push('--skip-blockchain');
+            }
             // Add password if encryption is enabled
             if (options.encrypt && options.password) {
                 args.push('-P', options.password);
@@ -1806,6 +1967,10 @@ async function testArchiveIntegrity(archiveName, options) {
                     else {
                         (0, utils_1.log)(`✅ Archive integrity test passed`, options);
                     }
+                    // For Zipstamp: clarify that timestamp is not validated and not minted
+                    if (options.blockchainZipstamp) {
+                        (0, utils_1.log)(`   Note: File integrity validated. Timestamp is pending (not yet confirmed on blockchain).`, options);
+                    }
                     resolve(true);
                 }
                 else {
@@ -1910,7 +2075,7 @@ async function upgradeZipForTokenization(inputZipPath, options) {
     }
     (0, utils_1.log)(`   Found ${entries.length} entries in ZIP`, options);
     // Check for existing token metadata (ignore per requirement 3a)
-    const hasTokenMetadata = entries.some((e) => e.filename === neozipkit_1.TOKENIZED_METADATA);
+    const hasTokenMetadata = entries.some((e) => e.filename === neozip_blockchain_1.TOKENIZED_METADATA);
     if (hasTokenMetadata && options.verbose) {
         (0, utils_1.log)(`   Note: ZIP already contains token metadata (will create new token)`, options);
     }
@@ -1922,9 +2087,11 @@ async function upgradeZipForTokenization(inputZipPath, options) {
         for (const entry of entries) {
             const filename = entry.filename || '';
             // Skip metadata entries and directories
-            if (filename === neozipkit_1.TOKENIZED_METADATA ||
-                filename === neozipkit_1.TIMESTAMP_METADATA ||
-                filename === neozipkit_1.TIMESTAMP_SUBMITTED ||
+            if (filename === neozip_blockchain_1.TOKENIZED_METADATA ||
+                filename === ots_1.TIMESTAMP_METADATA ||
+                filename === ots_1.TIMESTAMP_SUBMITTED ||
+                filename === zipstamp_server_1.SUBMIT_METADATA ||
+                filename === zipstamp_server_1.TIMESTAMP_METADATA ||
                 entry.isDirectory) {
                 continue;
             }
@@ -2080,7 +2247,7 @@ async function upgradeZipForTokenization(inputZipPath, options) {
             }
             // Mint new token before finalizing ZIP (so we can add metadata)
             // Check for wallet passkey - don't show error yet
-            const walletPasskey = (0, blockchain_2.getWalletPasskey)(options.walletKey, false);
+            const walletPasskey = (0, blockchain_1.getWalletPasskey)(options.walletKey, false);
             if (!walletPasskey) {
                 // Show error message and prompt user
                 console.error('❌ Error: Wallet private key is required for blockchain operations');
@@ -2118,10 +2285,10 @@ async function upgradeZipForTokenization(inputZipPath, options) {
             if (walletPasskey) {
                 (0, utils_1.log)(`   Minting new token on blockchain...`, options);
                 const network = options.network || 'base-sepolia';
-                if (!(0, blockchain_2.isSupportedNetwork)(network)) {
+                if (!(0, blockchain_1.isSupportedNetwork)(network)) {
                     (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR, `Error: Unsupported network: ${network}`);
                 }
-                const minter = new neozipkit_1.ZipkitMinter(merkleRoot, {
+                const minter = new neozip_blockchain_1.ZipkitMinter(merkleRoot, {
                     network,
                     walletPrivateKey: walletPasskey,
                     verbose: options.verbose,
@@ -2131,12 +2298,12 @@ async function upgradeZipForTokenization(inputZipPath, options) {
                 // Create a temporary ZipkitNode instance for handleTokenMinting
                 // (it needs a zip instance, but we'll add metadata manually)
                 const tempZip = new node_1.default();
-                const mintResult = await (0, blockchain_2.handleTokenMinting)(minter, tempZip, options.nonInteractive || false, 0);
+                const mintResult = await (0, blockchain_1.handleTokenMinting)(minter, tempZip, options.nonInteractive || false, 0);
                 if (mintResult.success && mintResult.tokenInfo) {
                     // Add token metadata entry before central directory
                     const tokenContent = JSON.stringify(mintResult.tokenInfo, null, 2);
                     const tokenBuffer = Buffer.from(tokenContent, 'utf8');
-                    const tokenEntry = new neozipkit_1.ZipEntry(neozipkit_1.TOKENIZED_METADATA, null, false);
+                    const tokenEntry = new neozipkit_1.ZipEntry(neozip_blockchain_1.TOKENIZED_METADATA, null, false);
                     tokenEntry.timeDateDOS = tokenEntry.setDateTime(new Date());
                     tokenEntry.compressedSize = tokenBuffer.length;
                     tokenEntry.uncompressedSize = tokenBuffer.length;