neozip-cli 0.75.1-beta → 0.80.0

package/dist/src/neounzip.js

@@ -48,8 +48,10 @@ exports.showExtendedHelp = showExtendedHelp;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const neozipkit_1 = require("neozipkit");
-const blockchain_1 = require("neozipkit/blockchain");
 const node_1 = __importDefault(require("neozipkit/node"));
+const neozip_blockchain_1 = require("neozip-blockchain");
+const ots_1 = require("neozip-blockchain/ots");
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
 const readline = __importStar(require("readline"));
 const version_1 = require("./version");
 const exit_codes_1 = require("./exit-codes");
@@ -283,6 +285,34 @@ async function promptForTimeoutAction(networkConfig, currentRpcIndex, nonInterac
         });
     });
 }
+/**
+ * Perform Zipstamp upgrade on the archive (TS-SUBMIT.NZIP -> TIMESTAMP.NZIP)
+ */
+async function performZipstampUpgrade(archivePath) {
+    try {
+        // Dynamic import: use path without .js for ts-node; tsc emits .js for dist
+        // @ts-expect-error TS2835 - node16 requires .js but ts-node resolves .ts from source
+        const { upgradeZipForTimestamp } = await import('./neozip/upgradeZip');
+        await upgradeZipForTimestamp(archivePath, undefined, { verbose: false, debug: false });
+        console.log(' - Upgraded archive saved. Re-run neounzip to extract.');
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.log(` - Upgrade failed: ${msg}`);
+    }
+}
+/**
+ * Prompt user for Zipstamp upgrade confirmation
+ */
+function promptForZipstampUpgrade(archiveName) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(` - Batch confirmed. Upgrade archive to TIMESTAMP.NZIP? (y/N): `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes');
+        });
+    });
+}
 /**
  * Perform OTS upgrade on the archive
  */
@@ -303,7 +333,7 @@ async function performOtsUpgrade(archivePath, upgradedOts) {
         fs.copyFileSync(archivePath, upgradedPath);
         console.log(` - Copied original file to upgrade location`);
         // Use the upgradeOTS function
-        await (0, blockchain_1.upgradeOTS)(upgradedPath, upgradedOts);
+        await (0, ots_1.upgradeOTS)(upgradedPath, upgradedOts);
         console.log(' - Upgrade: Applied successfully');
         console.log(` - Note: Upgraded timestamp saved to ${upgradedPath}`);
         console.log(` - Original file ${archivePath} remains unchanged`);
@@ -549,9 +579,11 @@ async function testArchive(zip, options) {
     // Filter out metadata files for merkle root calculation
     const contentEntriesForMerkle = 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 &&
             !entry.isDirectory;
     });
     for (const entry of entries) {
@@ -576,9 +608,11 @@ async function testArchive(zip, options) {
                 });
                 // Collect verified SHA-256 hash for merkle root calculation if available
                 if (testResult.verifiedHash && !options.skipBlockchain) {
-                    const isContentFile = name !== neozipkit_1.TOKENIZED_METADATA &&
-                        name !== neozipkit_1.TIMESTAMP_METADATA &&
-                        name !== neozipkit_1.TIMESTAMP_SUBMITTED &&
+                    const isContentFile = name !== neozip_blockchain_1.TOKENIZED_METADATA &&
+                        name !== ots_1.TIMESTAMP_METADATA &&
+                        name !== ots_1.TIMESTAMP_SUBMITTED &&
+                        name !== zipstamp_server_1.SUBMIT_METADATA &&
+                        name !== zipstamp_server_1.TIMESTAMP_METADATA &&
                         !entry.isDirectory;
                     if (isContentFile) {
                         // Use the verified hash returned from testEntry()
@@ -608,9 +642,11 @@ async function testArchive(zip, options) {
             // Check bitFlags for encryption flag (bit 0)
             const isEncrypted = entry.isEncrypted || (entry.bitFlags & 0x01) !== 0;
             // Track failed files for merkle root calculation
-            const isContentFile = name !== neozipkit_1.TOKENIZED_METADATA &&
-                name !== neozipkit_1.TIMESTAMP_METADATA &&
-                name !== neozipkit_1.TIMESTAMP_SUBMITTED &&
+            const isContentFile = name !== neozip_blockchain_1.TOKENIZED_METADATA &&
+                name !== ots_1.TIMESTAMP_METADATA &&
+                name !== ots_1.TIMESTAMP_SUBMITTED &&
+                name !== zipstamp_server_1.SUBMIT_METADATA &&
+                name !== zipstamp_server_1.TIMESTAMP_METADATA &&
                 !entry.isDirectory;
             if (isEncrypted) {
                 // For encrypted files, decompression errors after decryption usually mean wrong password
@@ -730,7 +766,7 @@ async function preVerifyArchive(zip, archiveName, options) {
     let verificationSuccess = false;
     let verificationError;
     try {
-        const verifier = new neozipkit_1.ZipkitVerifier({
+        const verifier = new neozip_blockchain_1.ZipkitVerifier({
             debug: options.verbose,
             skipHash: options.skipBlockchain
         });
@@ -791,21 +827,21 @@ async function preVerifyArchive(zip, archiveName, options) {
         const chainId = tokenMetadata.networkChainId;
         let networkConfig = null;
         if (chainId) {
-            networkConfig = (0, blockchain_1.getContractConfig)(chainId);
+            networkConfig = (0, neozip_blockchain_1.getContractConfig)(chainId);
         }
         else {
             const networkName = tokenMetadata.network.toLowerCase();
             if (networkName.includes('base sepolia') || networkName === 'base-sepolia') {
-                networkConfig = (0, blockchain_1.getContractConfig)(84532);
+                networkConfig = (0, neozip_blockchain_1.getContractConfig)(84532);
             }
             else if (networkName.includes('base mainnet') || networkName === 'base-mainnet' || networkName === 'base') {
-                networkConfig = (0, blockchain_1.getContractConfig)(8453);
+                networkConfig = (0, neozip_blockchain_1.getContractConfig)(8453);
             }
             else if (networkName.includes('arbitrum sepolia') || networkName === 'arbitrum-sepolia' || (networkName.includes('arbitrum') && networkName.includes('sepolia'))) {
-                networkConfig = (0, blockchain_1.getContractConfig)(421614);
+                networkConfig = (0, neozip_blockchain_1.getContractConfig)(421614);
             }
             else if (networkName.includes('sepolia testnet') || networkName === 'sepolia-testnet' || (networkName.includes('sepolia') && !networkName.includes('base') && !networkName.includes('arbitrum'))) {
-                networkConfig = (0, blockchain_1.getContractConfig)(11155111);
+                networkConfig = (0, neozip_blockchain_1.getContractConfig)(11155111);
             }
         }
         // Perform verification (non-interactive mode for pre-verify)
@@ -926,9 +962,11 @@ async function extractArchive(zip, destination, options) {
     // Filter out metadata files for merkle root calculation
     const contentEntriesForMerkle = filteredEntries.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 &&
             !entry.isDirectory;
     });
     for (const entry of filteredEntries) {
@@ -1005,9 +1043,11 @@ async function extractArchive(zip, destination, options) {
             // Collect verified SHA-256 hash for merkle root calculation (single pass - no double check)
             // Only if this is a content file (not metadata) and SHA-256 verification was performed
             if (!options.skipBlockchain && hasSha) {
-                const isContentFile = filename !== neozipkit_1.TOKENIZED_METADATA &&
-                    filename !== neozipkit_1.TIMESTAMP_METADATA &&
-                    filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
+                const isContentFile = 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;
                 if (isContentFile && entry.sha256) {
                     // Use the verified hash from the entry (already verified during extraction)
@@ -1019,9 +1059,11 @@ async function extractArchive(zip, destination, options) {
         else {
             log(`error: ${filename} (${result.error || 'unknown error'})`, options);
             // Track failed files for merkle root calculation
-            const isContentFile = filename !== neozipkit_1.TOKENIZED_METADATA &&
-                filename !== neozipkit_1.TIMESTAMP_METADATA &&
-                filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
+            const isContentFile = 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;
             if (isContentFile && !options.skipBlockchain) {
                 // Check if failure was due to SHA-256 mismatch
@@ -1051,9 +1093,12 @@ async function extractArchive(zip, destination, options) {
 async function verifyTokenization(zip, archiveName, options, extractionResult) {
     try {
         const entries = await getDirectory(zip, false);
-        const tokenEntry = entries.find((e) => (e.filename || '') === 'META-INF/NZIP.TOKEN');
+        const tokenEntryLegacy = entries.find((e) => (e.filename || '') === 'META-INF/NZIP.TOKEN');
+        const tokenEntryNzip = entries.find((e) => (e.filename || '') === 'META-INF/TOKEN.NZIP');
+        const tokenEntry = tokenEntryNzip || tokenEntryLegacy;
+        const tokenMetaFile = tokenEntry ? (tokenEntry.filename || 'META-INF/TOKEN.NZIP') : '';
         if (tokenEntry) {
-            console.log('\nTokenization detected (META-INF/NZIP.TOKEN)');
+            console.log(`\nTokenization detected (${tokenMetaFile})`);
         }
         // Only do token verification if there's a token entry
         if (tokenEntry) {
@@ -1063,7 +1108,7 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
                 return;
             }
             // Initialize blockchain verifier
-            const verifier = new neozipkit_1.ZipkitVerifier({
+            const verifier = new neozip_blockchain_1.ZipkitVerifier({
                 debug: options.verbose, // Enable debug output in verbose mode
                 skipHash: options.skipBlockchain
             });
@@ -1155,9 +1200,11 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
                     // 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 &&
                             !entry.isDirectory; // Skip directories
                     });
                     // Extract each file once and verify SHA-256 during extraction
@@ -1270,22 +1317,22 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
             const chainId = tokenMetadata.networkChainId;
             let networkConfig = null;
             if (chainId) {
-                networkConfig = (0, blockchain_1.getContractConfig)(chainId);
+                networkConfig = (0, neozip_blockchain_1.getContractConfig)(chainId);
             }
             else {
                 // Fallback: try to determine chain ID from network name
                 const networkName = tokenMetadata.network.toLowerCase();
                 if (networkName.includes('base sepolia') || networkName === 'base-sepolia') {
-                    networkConfig = (0, blockchain_1.getContractConfig)(84532);
+                    networkConfig = (0, neozip_blockchain_1.getContractConfig)(84532);
                 }
                 else if (networkName.includes('base mainnet') || networkName === 'base-mainnet' || networkName === 'base') {
-                    networkConfig = (0, blockchain_1.getContractConfig)(8453);
+                    networkConfig = (0, neozip_blockchain_1.getContractConfig)(8453);
                 }
                 else if (networkName.includes('arbitrum sepolia') || networkName === 'arbitrum-sepolia' || (networkName.includes('arbitrum') && networkName.includes('sepolia'))) {
-                    networkConfig = (0, blockchain_1.getContractConfig)(421614);
+                    networkConfig = (0, neozip_blockchain_1.getContractConfig)(421614);
                 }
                 else if (networkName.includes('sepolia testnet') || networkName === 'sepolia-testnet' || (networkName.includes('sepolia') && !networkName.includes('base') && !networkName.includes('arbitrum'))) {
-                    networkConfig = (0, blockchain_1.getContractConfig)(11155111);
+                    networkConfig = (0, neozip_blockchain_1.getContractConfig)(11155111);
                 }
             }
             let verificationResult;
@@ -1437,26 +1484,36 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
             }
             // Display results based on verification outcome
             if (verificationResult.success && verificationResult.verificationDetails) {
-                // Show Merkle Root verification first
-                if (verificationResult.verificationDetails.merkleRoot && verificationResult.verificationDetails.calculatedMerkleRoot) {
-                    const contractRoot = verificationResult.verificationDetails.merkleRoot;
-                    const calculatedRoot = verificationResult.verificationDetails.calculatedMerkleRoot;
-                    const rootsMatch = contractRoot === calculatedRoot;
-                    console.log(`🔐 Merkle Root: ${contractRoot}`);
-                    if (rootsMatch) {
-                        console.log(`✓ Contract Merkle Root verified against calculated Merkle Root`);
-                    }
+                const d = verificationResult.verificationDetails;
+                const meta = verificationResult.tokenMetadata;
+                // Stamp type and summary
+                console.log('\n🔐 Tokenization (NFT) Verification:');
+                console.log(' - Status: ✅ VERIFIED');
+                console.log(' - Stamp type: NZIP-NFT (tokenized archive)');
+                if (d.contractAddress) {
+                    console.log(` - Contract: ${d.contractAddress}`);
                 }
-                // Green checkmark for successful verification
-                // NOTE: All verification data (merkle root, mint date) comes from blockchain, not metadata
-                console.log(`✅ ${verificationResult.message}.`);
-                console.log(`The archive, tokenized as NFT #${verificationResult.verificationDetails.tokenId} on the ${verificationResult.verificationDetails.network}, was minted on ${verificationResult.verificationDetails.mintDate}.`);
-                if (options.verbose && verificationResult.verificationDetails) {
-                    console.log(`  Contract: ${verificationResult.verificationDetails.contractAddress}`);
-                    console.log(`  Network: ${verificationResult.verificationDetails.network}`);
-                    if (verificationResult.verificationDetails.declaredMerkleRoot) {
-                        console.log(`  Declared: ${verificationResult.verificationDetails.declaredMerkleRoot}`);
-                    }
+                if (meta?.contractVersion) {
+                    console.log(` - Contract version: ${meta.contractVersion}`);
+                }
+                if (d.network) {
+                    console.log(` - Network: ${d.network}`);
+                }
+                if (d.tokenId) {
+                    console.log(` - Token ID: ${d.tokenId}`);
+                }
+                if (d.merkleRoot && d.calculatedMerkleRoot) {
+                    const rootsMatch = d.merkleRoot === d.calculatedMerkleRoot;
+                    console.log(` - Merkle root: ${d.merkleRoot}`);
+                    console.log(`   ${rootsMatch ? '✓' : '✗'} Contract Merkle Root ${rootsMatch ? 'matches' : 'does not match'} calculated Merkle Root`);
+                }
+                if (d.mintDate) {
+                    console.log(` - Minted: ${d.mintDate}`);
+                }
+                console.log(`✅ ${verificationResult.message}`);
+                console.log(`The archive, tokenized as NFT #${d.tokenId} on the ${d.network}, was minted on ${d.mintDate}.`);
+                if (options.verbose && d.declaredMerkleRoot) {
+                    console.log(`  Declared Merkle Root: ${d.declaredMerkleRoot}`);
                 }
             }
             else {
@@ -1497,6 +1554,8 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
         } // End of token verification if statement
         // Check for OpenTimestamp verification and upgrade
         await verifyAndUpgradeOts(zip, archiveName, options);
+        // Check for Zipstamp verification
+        await verifyZipstampTimestamp(zip, archiveName, options, extractionResult);
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
@@ -1520,7 +1579,7 @@ async function verifyAndUpgradeOts(zip, archiveName, options) {
         if (!otsEntry) {
             return;
         }
-        const res = await (0, neozipkit_1.verifyOtsZip)(zip);
+        const res = await (0, ots_1.verifyOtsZip)(zip);
         console.log('\n🕐 OpenTimestamps Verification:');
         if (res.status === 'none') {
             console.log(' - Status: No OpenTimestamps found');
@@ -1539,10 +1598,12 @@ async function verifyAndUpgradeOts(zip, archiveName, options) {
                     hour12: false
                 });
                 console.log(` - Status: ✅ VERIFIED`);
+                console.log(` - Stamp type: OpenTimestamps (Bitcoin)`);
                 console.log(` - Attested: Bitcoin block ${res.blockHeight} on ${date} ${time}`);
             }
             else {
                 console.log(' - Status: ✅ VERIFIED');
+                console.log(' - Stamp type: OpenTimestamps (Bitcoin)');
             }
             if (res.upgraded && res.upgradedOts) {
                 let doUpgrade = false;
@@ -1605,6 +1666,182 @@ async function verifyAndUpgradeOts(zip, archiveName, options) {
         }
     }
 }
+/**
+ * Verify Zipstamp timestamp if present
+ * Uses our extraction logic (extractEntry/extractToFile) for compatibility with file-based ZIPs
+ * When batch is confirmed but archive has TS-SUBMIT.NZIP, offers upgrade (prompt/auto/skip)
+ */
+async function verifyZipstampTimestamp(zip, archiveName, options, extractionResult) {
+    try {
+        if (options.skipBlockchain) {
+            return;
+        }
+        const entries = await getDirectory(zip, false);
+        const zipstampEntry = entries.find((e) => (e.filename || '') === 'META-INF/TS-SUBMIT.NZIP' ||
+            (e.filename || '') === 'META-INF/TIMESTAMP.NZIP');
+        if (!zipstampEntry) {
+            return;
+        }
+        // Extract timestamp metadata using our extraction (works for both buffer and file-based)
+        let timestampData = null;
+        const bufferBased = isBufferBased(zip);
+        const fileBased = isFileBased(zip);
+        if (bufferBased) {
+            const buf = await extractEntry(zip, zipstampEntry, true);
+            if (buf) {
+                try {
+                    timestampData = JSON.parse(buf.toString('utf-8'));
+                }
+                catch {
+                    timestampData = null;
+                }
+            }
+        }
+        else if (fileBased) {
+            const tmpPath = path.join(require('os').tmpdir(), `neounzip-zipstamp-${Date.now()}-${(zipstampEntry.filename || 'meta').replace(/[^a-zA-Z0-9]/g, '_')}`);
+            try {
+                await zip.extractToFile(zipstampEntry, tmpPath, { skipHashCheck: true });
+                const buf = fs.readFileSync(tmpPath);
+                timestampData = JSON.parse(buf.toString('utf-8'));
+            }
+            catch {
+                timestampData = null;
+            }
+            finally {
+                if (fs.existsSync(tmpPath)) {
+                    try {
+                        fs.unlinkSync(tmpPath);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+        }
+        if (!timestampData || !timestampData.digest) {
+            console.log('\n🔗 Zipstamp Verification:');
+            console.log(' - Status: ❌ ERROR');
+            console.log(' - Error: Failed to extract timestamp metadata');
+            return;
+        }
+        const merkleRoot = extractionResult?.merkleRoot ??
+            zip.getMerkleRoot?.() ??
+            null;
+        if (!merkleRoot) {
+            console.log('\n🔗 Zipstamp Verification:');
+            console.log(' - Status: ❌ ERROR');
+            console.log(' - Error: Merkle root not found in ZIP file');
+            return;
+        }
+        if (timestampData.digest.toLowerCase() !== merkleRoot.toLowerCase()) {
+            console.log('\n🔗 Zipstamp Verification:');
+            console.log(' - Status: ❌ ERROR');
+            console.log(' - Error: Timestamp digest does not match ZIP merkle root');
+            return;
+        }
+        // Use verifyDigest directly - pass undefined for chainId when 0/invalid (server may reject chainId 0)
+        const chainId = timestampData.chainId && timestampData.chainId > 0 ? timestampData.chainId : undefined;
+        const batchId = timestampData.batchId || undefined;
+        const response = await (0, zipstamp_server_1.verifyDigest)(merkleRoot, chainId, batchId, undefined, {
+            debug: options.debug ?? false,
+        });
+        const res = response.success
+            ? response.verified
+                ? {
+                    status: 'valid',
+                    transactionHash: response.transactionHash,
+                    blockNumber: response.blockNumber,
+                    timestamp: response.timestamp,
+                    network: response.network,
+                    contractAddress: response.contractAddress,
+                    chainId: response.chainId,
+                }
+                : { status: 'pending', message: 'Timestamp is pending confirmation' }
+            : { status: 'error', message: response.error || 'Verification failed' };
+        console.log('\n🔗 Zipstamp Verification:');
+        if (res.status === 'valid') {
+            console.log(' - Status: ✅ VERIFIED');
+            console.log(' - Stamp type: Zipstamp (blockchain timestamp)');
+            if (res.network) {
+                console.log(` - Network: ${res.network}`);
+            }
+            if (res.contractAddress) {
+                console.log(` - Contract: ${res.contractAddress}`);
+            }
+            if (res.transactionHash) {
+                console.log(` - Transaction: ${res.transactionHash}`);
+            }
+            if (res.blockNumber !== undefined) {
+                console.log(` - Block: ${res.blockNumber}`);
+            }
+            if (res.timestamp !== undefined && res.timestamp != null) {
+                const blockDate = new Date(res.timestamp * 1000);
+                const mintedStr = blockDate.toLocaleString(undefined, {
+                    month: '2-digit',
+                    day: '2-digit',
+                    year: 'numeric',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    hour12: true,
+                });
+                console.log(` - Block timestamp (minted): ${mintedStr}`);
+            }
+            // Offer upgrade when archive has TS-SUBMIT.NZIP but batch is confirmed
+            const hasPendingMetadata = (zipstampEntry.filename || '') === 'META-INF/TS-SUBMIT.NZIP';
+            if (hasPendingMetadata) {
+                let doUpgrade = false;
+                if (options.zipstampSkipUpgrade) {
+                    doUpgrade = false;
+                    console.log(' - Upgrade: Skipped (--zipstamp-skip-upgrade)');
+                }
+                else if (options.zipstampAutoUpgrade) {
+                    doUpgrade = true;
+                    console.log(' - Upgrade: Automatically applying (--zipstamp-auto-upgrade)');
+                }
+                else {
+                    doUpgrade = await promptForZipstampUpgrade(archiveName);
+                }
+                if (doUpgrade) {
+                    await performZipstampUpgrade(archiveName);
+                }
+                else if (!options.zipstampSkipUpgrade && !options.zipstampAutoUpgrade) {
+                    console.log(' - Note: Run "neozip upgrade <archive>" to upgrade when ready');
+                }
+            }
+            return;
+        }
+        if (res.status === 'pending') {
+            console.log(' - Status: ⏳ PENDING (batch not yet confirmed on blockchain)');
+            if (res.message) {
+                console.log(` - Info: ${res.message}`);
+            }
+            console.log(' - Note: Run "neozip upgrade <archive>" to upgrade when confirmed');
+            return;
+        }
+        if (res.status === 'error') {
+            console.log(' - Status: ❌ ERROR');
+            if (res.message) {
+                console.log(` - Error: ${res.message}`);
+            }
+            return;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.log('\n🔗 Zipstamp Verification:');
+        if (errorMessage.includes('ESOCKETTIMEDOUT') || errorMessage.includes('ECONNRESET') ||
+            errorMessage.includes('ENOTFOUND') || errorMessage.includes('ECONNREFUSED') ||
+            errorMessage.includes('timeout') || errorMessage.includes('network')) {
+            console.log(' - Status: 📡 COMMUNICATION ERROR (unable to contact Zipstamp server)');
+            console.log(` - Error: ${errorMessage}`);
+        }
+        else {
+            console.log(' - Status: ❌ ERROR during verification');
+            console.log(` - Error: ${errorMessage}`);
+        }
+    }
+}
 /**
  * Parse command line arguments
  */
@@ -1772,6 +2009,12 @@ function parseArgs(args) {
             case '--ots-skip-upgrade':
                 options.otsSkipUpgrade = true;
                 break;
+            case '--zipstamp-auto-upgrade':
+                options.zipstampAutoUpgrade = true;
+                break;
+            case '--zipstamp-skip-upgrade':
+                options.zipstampSkipUpgrade = true;
+                break;
             case '--in-memory':
                 options.inMemory = true;
                 break;
@@ -1854,6 +2097,8 @@ Options:
   -H, --hard-links       Restore hard links efficiently (recreate link relationships)
       --ots-auto-upgrade Automatically upgrade OTS timestamps when available
       --ots-skip-upgrade Skip OTS timestamp upgrades (no prompt)
+      --zipstamp-auto-upgrade Automatically upgrade Zipstamp timestamps when confirmed
+      --zipstamp-skip-upgrade Skip Zipstamp timestamp upgrades (no prompt)
       --in-memory        Force in-memory processing mode (browser compatible)
 
 Arguments:
@@ -1861,9 +2106,9 @@ Arguments:
   [destination]    Output directory (default: current directory)
 
 Examples:
-  neounzip output/calgary.nzip ./extracted
-  neounzip -t output/calgary.nzip
-  neounzip -l output/calgary.nzip
+  neounzip tests/output/calgary.nzip tests/extracted
+  neounzip -t tests/output/calgary.nzip
+  neounzip -l tests/output/calgary.nzip
 `);
 }
 /**

package/dist/src/neozip/blockchain.js

@@ -41,14 +41,14 @@ exports.getWalletPasskey = getWalletPasskey;
 exports.addTokenMetaToZip = addTokenMetaToZip;
 exports.handleTokenMinting = handleTokenMinting;
 const neozipkit_1 = require("neozipkit");
-const blockchain_1 = require("neozipkit/blockchain");
+const neozip_blockchain_1 = require("neozip-blockchain");
 const ConfigStore_1 = require("../config/ConfigStore");
 const readline = __importStar(require("readline"));
 /**
  * Check if the network is supported (uses nameAliases from CONTRACT_CONFIGS)
  */
 function isSupportedNetwork(network) {
-    return (0, blockchain_1.getChainIdByName)(network) !== null;
+    return (0, neozip_blockchain_1.getChainIdByName)(network) !== null;
 }
 /**
  * Check if the required wallet passkey is available and valid
@@ -78,7 +78,7 @@ function getWalletPasskey(cliWalletKey, showError = true) {
         return null;
     }
     // Validate the private key format
-    if (!(0, blockchain_1.validatePrivateKey)(passkey)) {
+    if (!(0, neozip_blockchain_1.validatePrivateKey)(passkey)) {
         if (showError) {
             console.error('❌ Error: Invalid private key format');
             console.error('   Private key should be a 64-character hex string starting with 0x');
@@ -94,7 +94,7 @@ function getWalletPasskey(cliWalletKey, showError = true) {
 async function addTokenMetaToZip(zip, tokenMeta) {
     const tokenContent = JSON.stringify(tokenMeta, null, 2);
     const tokenBuffer = Buffer.from(tokenContent, 'utf8');
-    const tokenPath = neozipkit_1.TOKENIZED_METADATA;
+    const tokenPath = neozip_blockchain_1.TOKENIZED_METADATA;
     // Create new token entry
     const tokenEntry = zip.createZipEntry(tokenPath);
     tokenEntry.timeDateDOS = tokenEntry.setDateTime(new Date());
@@ -193,7 +193,7 @@ async function handleTokenMinting(initialMinter, zip, nonInteractive = false, in
                 else {
                     // ZipkitMinter uses getChainIdByName internally which handles all nameAliases
                     // So we can pass the original network name directly
-                    minter = new neozipkit_1.ZipkitMinter(merkleRoot, {
+                    minter = new neozip_blockchain_1.ZipkitMinter(merkleRoot, {
                         network: network,
                         walletPrivateKey: walletPrivateKey,
                         verbose: verbose,