neozip-cli 0.75.1-beta → 0.80.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,7 +404,9 @@ 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);
+        if (!this.options.blockchainZipstamp && !this.options.blockchainOts) {
+            (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);
         (0, utils_1.log)('', this.options);
@@ -433,6 +438,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,7 +820,7 @@ 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'
         };
@@ -829,7 +838,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 +920,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 +989,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 +1072,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 +1154,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 +1175,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 +1204,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 +1295,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 +1309,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 +1319,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 +1328,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 +1399,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 +1436,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 +1556,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 +1605,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 +1904,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 +1915,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 +1966,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 +2074,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 +2086,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 +2246,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 +2284,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 +2297,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;

package/dist/src/neozip/upgradeZip.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Upgrade Zipstamp timestamp from pending (TS-SUBMIT.NZIP) to confirmed (TIMESTAMP.NZIP)
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upgradeZipForTimestamp = upgradeZipForTimestamp;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const node_1 = __importDefault(require("neozipkit/node"));
+const node_2 = require("neozipkit/node");
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const exit_codes_1 = require("../exit-codes");
+/**
+ * Extract timestamp metadata from a ZIP entry.
+ * Tries the library's extractTimestampData first; if it fails (e.g. file-based ZIP),
+ * fall back to extracting to a temp file and parsing JSON.
+ */
+async function extractTimestampMetadata(zip, entry) {
+    let metadata = await (0, zipstamp_server_1.extractTimestampData)(zip, entry);
+    if (metadata)
+        return metadata;
+    // Fallback for file-based ZIPs where zip.extract() may not work
+    try {
+        const tmpPath = path.join(os.tmpdir(), `neozip-upgrade-meta-${Date.now()}.json`);
+        await zip.extractToFile(entry, tmpPath, { skipHashCheck: true });
+        try {
+            const buf = fs.readFileSync(tmpPath);
+            return JSON.parse(buf.toString('utf-8'));
+        }
+        finally {
+            if (fs.existsSync(tmpPath))
+                fs.unlinkSync(tmpPath);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Upgrade a ZIP file with pending Zipstamp timestamp to confirmed status.
+ * Replaces TS-SUBMIT.NZIP with TIMESTAMP.NZIP when the batch is confirmed on the blockchain.
+ */
+async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
+    const { wait = false, verbose = false, debug = false } = options;
+    if (!fs.existsSync(inputPath)) {
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE, `Error: ZIP file not found: ${inputPath}`);
+    }
+    const zip = new node_1.default();
+    await zip.loadZipFile(inputPath);
+    const entries = zip.getDirectory() || [];
+    const metadataResult = (0, zipstamp_server_1.findMetadataEntry)(entries);
+    if (!metadataResult) {
+        console.log('No Zipstamp timestamp found in ZIP file');
+        return;
+    }
+    if (metadataResult.type === 'confirmed') {
+        console.log('✓ Timestamp already confirmed - no upgrade needed');
+        return;
+    }
+    const metadata = await extractTimestampMetadata(zip, metadataResult.entry);
+    if (!metadata || !metadata.digest) {
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, 'Error: Failed to extract timestamp metadata');
+    }
+    if (!(0, zipstamp_server_1.shouldUpgrade)(metadata, metadataResult.type)) {
+        console.log('✓ Timestamp does not need upgrade');
+        return;
+    }
+    const digest = metadata.digest;
+    const chainId = metadata.chainId && metadata.chainId > 0 ? metadata.chainId : undefined;
+    const batchId = metadata.batchId ?? undefined;
+    let verified = null;
+    if (wait) {
+        if (verbose || debug)
+            console.log('Polling for confirmation (--wait)...');
+        verified = await (0, zipstamp_server_1.pollForConfirmation)(digest, chainId, batchId, 300000, 5000, { debug });
+    }
+    else {
+        const verifyRes = await (0, zipstamp_server_1.verifyDigest)(digest, chainId, batchId, undefined, { debug });
+        if (verifyRes.verified) {
+            verified = verifyRes;
+        }
+    }
+    if (!verified || !verified.verified) {
+        console.log('⏳ Timestamp not yet confirmed on blockchain');
+        console.log('   Run with --wait to poll until confirmed, or try again later');
+        return;
+    }
+    console.log('✓ Timestamp confirmed on blockchain');
+    if (verified.transactionHash && (verbose || debug)) {
+        console.log(`   Transaction: ${verified.transactionHash}`);
+    }
+    const confirmedMetadata = {
+        ...metadata,
+        status: 'confirmed',
+        merkleProof: verified.merkleProof ?? metadata.merkleProof,
+        merkleRoot: verified.merkleRoot ?? metadata.merkleRoot,
+        transactionHash: verified.transactionHash ?? metadata.transactionHash,
+        blockNumber: verified.blockNumber ?? metadata.blockNumber,
+        timestamp: verified.timestamp ?? metadata.timestamp
+    };
+    const metadataFiles = (0, zipstamp_server_1.getMetadataFileNames)();
+    const outPath = outputPath ?? inputPath.replace(/(\.nzip|\.zip)$/i, '-upgrade$1');
+    const tempDir = path.dirname(outPath) || '.';
+    const tempPath = path.join(tempDir, `.neozip-upgrade-${Date.now()}.tmp`);
+    try {
+        const zipCopy = new node_2.ZipCopyNode(new node_1.default());
+        const { destPath, dataEndOffset, copiedEntries } = await zipCopy.copyZipEntriesOnly(inputPath, tempPath, {
+            entryFilter: (entry) => !metadataFiles.includes(entry.filename || '')
+        });
+        const newEntry = (0, zipstamp_server_1.createTimestampMetadataEntry)(zip, confirmedMetadata);
+        if (!newEntry) {
+            throw new Error('Failed to create timestamp metadata entry');
+        }
+        newEntry.localHdrOffset = dataEndOffset;
+        newEntry.cmpMethod = 0;
+        newEntry.compressedSize = newEntry.fileBuffer?.length ?? newEntry.uncompressedSize ?? 0;
+        const localHdr = newEntry.createLocalHdr();
+        const data = newEntry.fileBuffer ?? Buffer.alloc(0);
+        const fd = fs.openSync(destPath, 'r+');
+        try {
+            fs.writeSync(fd, localHdr, 0, localHdr.length, dataEndOffset);
+            fs.writeSync(fd, data, 0, data.length, dataEndOffset + localHdr.length);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        const allEntries = [...copiedEntries, newEntry];
+        zipCopy.writeCentralDirectoryAndEOCD(destPath, allEntries, { zipComment: '' });
+        fs.renameSync(destPath, outPath);
+        console.log(`✓ Upgraded ZIP written to: ${outPath}`);
+    }
+    catch (error) {
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_WRITE_ARCHIVE, `Error upgrading ZIP: ${msg}`);
+    }
+}
+//# sourceMappingURL=upgradeZip.js.map