neozip-cli 0.70.0-alpha → 0.75.1-beta

package/dist/neozipkit-wrappers/index.js

@@ -1,13 +1,13 @@
 // Main neozipkit wrapper - re-exports from core and blockchain bundles
 const core = require('../neozipkit-bundles/core.js');
 const blockchain = require('../neozipkit-bundles/blockchain.js');
-const server = require('../neozipkit-bundles/server.js');
+const node = require('../neozipkit-bundles/node.js');
 
 // Merge all exports
 module.exports = {
   ...core,
   ...blockchain,
-  ...server,
+  ...node,
   // Ensure default export is available
   default: core.default || core
 };

package/dist/neozipkit-wrappers/node/index.js

@@ -0,0 +1,2 @@
+// Node.js neozipkit wrapper - re-exports from node bundle
+module.exports = require('../../neozipkit-bundles/node.js');

package/dist/src/config/ConfigSetup.js

@@ -41,7 +41,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigSetup = void 0;
 const readline = __importStar(require("readline"));
 const ConfigStore_1 = require("./ConfigStore");
-const contracts_1 = require('../../neozipkit-wrappers/blockchain/core/contracts');
+const blockchain_1 = require("neozipkit/blockchain");
 class ConfigSetup {
     constructor() {
         this.rl = readline.createInterface({
@@ -148,7 +148,7 @@ class ConfigSetup {
             // Dynamically build network options from CONTRACT_CONFIGS
             // CONTRACT_CONFIGS is already ordered correctly: Base (testnet/mainnet), Arbitrum (testnet/mainnet), Ethereum
             const networkOptions = [];
-            const networkConfigs = Object.values(contracts_1.CONTRACT_CONFIGS);
+            const networkConfigs = Object.values(blockchain_1.CONTRACT_CONFIGS);
             // Verify we're loading networks
             if (networkConfigs.length === 0) {
                 console.error('❌ Error: No networks found in CONTRACT_CONFIGS');
@@ -160,7 +160,7 @@ class ConfigSetup {
                 // Use the primary alias (first nameAlias) or network name as value
                 const primaryAlias = config.nameAliases && config.nameAliases.length > 0
                     ? config.nameAliases[0]
-                    : (0, contracts_1.normalizeNetworkName)(config.network);
+                    : (0, blockchain_1.normalizeNetworkName)(config.network);
                 // Determine description based on network type
                 const isTestnet = config.network.toLowerCase().includes('testnet') ||
                     config.network.toLowerCase().includes('sepolia');
@@ -188,7 +188,7 @@ class ConfigSetup {
             }
             if (useCustomRpc === 'y') {
                 // Get the selected network config to show default RPC
-                const selectedNetworkConfig = (0, contracts_1.getNetworkByName)(network);
+                const selectedNetworkConfig = (0, blockchain_1.getNetworkByName)(network);
                 // Prompt for RPC URL for the selected network
                 if (selectedNetworkConfig) {
                     const defaultRpc = selectedNetworkConfig.rpcUrls && selectedNetworkConfig.rpcUrls.length > 0
@@ -197,12 +197,12 @@ class ConfigSetup {
                     // Use primary alias as RPC key for consistency (or normalized network name as fallback)
                     const rpcKey = (selectedNetworkConfig.nameAliases && selectedNetworkConfig.nameAliases.length > 0)
                         ? selectedNetworkConfig.nameAliases[0]
-                        : (0, contracts_1.normalizeNetworkName)(selectedNetworkConfig.network);
+                        : (0, blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network);
                     // Check both new format and legacy format for backward compatibility
                     const existingRpc = rpcConfig[rpcKey]
-                        || rpcConfig[(0, contracts_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')]
+                        || rpcConfig[(0, blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')]
                         || existingConfig?.rpc?.[rpcKey]
-                        || existingConfig?.rpc?.[(0, contracts_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')];
+                        || existingConfig?.rpc?.[(0, blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')];
                     const customRpc = await this.prompt(`   ${selectedNetworkConfig.network} RPC URL`, existingRpc || defaultRpc);
                     if (customRpc) {
                         rpcConfig[rpcKey] = customRpc;
@@ -218,21 +218,21 @@ class ConfigSetup {
                         // Skip the already configured network
                         const configAlias = config.nameAliases && config.nameAliases.length > 0
                             ? config.nameAliases[0]
-                            : (0, contracts_1.normalizeNetworkName)(config.network);
+                            : (0, blockchain_1.normalizeNetworkName)(config.network);
                         if (configAlias === network)
                             continue;
                         // Use primary alias as RPC key for consistency (or normalized network name as fallback)
                         const rpcKey = (config.nameAliases && config.nameAliases.length > 0)
                             ? config.nameAliases[0]
-                            : (0, contracts_1.normalizeNetworkName)(config.network);
+                            : (0, blockchain_1.normalizeNetworkName)(config.network);
                         const defaultRpc = config.rpcUrls && config.rpcUrls.length > 0
                             ? config.rpcUrls[0]
                             : '';
                         // Check both new format and legacy format for backward compatibility
                         const existingRpc = rpcConfig[rpcKey]
-                            || rpcConfig[(0, contracts_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')]
+                            || rpcConfig[(0, blockchain_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')]
                             || existingConfig?.rpc?.[rpcKey]
-                            || existingConfig?.rpc?.[(0, contracts_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')];
+                            || existingConfig?.rpc?.[(0, blockchain_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')];
                         const customRpc = await this.prompt(`   ${config.network} RPC URL`, existingRpc || defaultRpc);
                         if (customRpc) {
                             rpcConfig[rpcKey] = customRpc;

package/dist/src/config/ConfigStore.js

@@ -42,7 +42,7 @@ exports.ConfigStore = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
-const contracts_1 = require('../../neozipkit-wrappers/blockchain/core/contracts');
+const blockchain_1 = require("neozipkit/blockchain");
 const DEFAULTS = {
     network: 'base-sepolia',
     rpcUrls: {
@@ -198,7 +198,7 @@ class ConfigStore {
      * Validate network name (uses nameAliases from CONTRACT_CONFIGS)
      */
     static validateNetwork(network) {
-        return (0, contracts_1.getChainIdByName)(network) !== null;
+        return (0, blockchain_1.getChainIdByName)(network) !== null;
     }
     /**
      * Update a specific configuration value
@@ -223,7 +223,7 @@ class ConfigStore {
                 }
                 else if (parts[1] === 'network') {
                     if (!this.validateNetwork(value)) {
-                        const supportedNetworks = (0, contracts_1.getSupportedNetworkNames)();
+                        const supportedNetworks = (0, blockchain_1.getSupportedNetworkNames)();
                         console.error(`❌ Invalid network: "${value}"`);
                         console.error(`Supported networks: ${supportedNetworks.join(', ')}`);
                         return false;

package/dist/src/neolist.js

@@ -46,8 +46,8 @@ exports.parseArgs = parseArgs;
 exports.showHelp = showHelp;
 exports.showExtendedHelp = showExtendedHelp;
 const fs = __importStar(require("fs"));
-const server_1 = require('../neozipkit-wrappers/server');
-const src_1 = require('../neozipkit-wrappers');
+const neozipkit_1 = require("neozipkit");
+const node_1 = __importDefault(require("neozipkit/node"));
 const chalk_1 = __importDefault(require("chalk"));
 const ora_1 = __importDefault(require("ora"));
 const version_1 = require("./version");
@@ -248,14 +248,14 @@ function getActualCompressedSize(entry) {
  * Format entry name for display (handles blockchain metadata)
  */
 function formatEntryName(entry) {
-    if (entry.filename === src_1.TOKENIZED_METADATA) {
-        return `${src_1.TOKENIZED_METADATA} (NFT Token)`;
+    if (entry.filename === neozipkit_1.TOKENIZED_METADATA) {
+        return `${neozipkit_1.TOKENIZED_METADATA} (NFT Token)`;
     }
-    if (entry.filename === src_1.TIMESTAMP_METADATA) {
-        return `${src_1.TIMESTAMP_METADATA} (Timestamp Metadata)`;
+    if (entry.filename === neozipkit_1.TIMESTAMP_METADATA) {
+        return `${neozipkit_1.TIMESTAMP_METADATA} (Timestamp Metadata)`;
     }
-    if (entry.filename === src_1.TIMESTAMP_SUBMITTED) {
-        return `${src_1.TIMESTAMP_SUBMITTED} (Timestamp Submitted)`;
+    if (entry.filename === neozipkit_1.TIMESTAMP_SUBMITTED) {
+        return `${neozipkit_1.TIMESTAMP_SUBMITTED} (Timestamp Submitted)`;
     }
     return entry.filename;
 }
@@ -268,8 +268,8 @@ async function readArchiveEntries(archivePath, debugMode = false, quiet = false,
         if (!quiet) {
             spinner = (0, ora_1.default)('Reading archive...').start();
         }
-        // Create ZipkitServer instance
-        const zip = new server_1.ZipkitServer();
+        // Create ZipkitNode instance
+        const zip = new node_1.default();
         let entries;
         if (inMemory) {
             // For Buffer-based loading, read the entire file into buffer and get entries in one call

package/dist/src/neounzip.js

@@ -47,11 +47,9 @@ exports.showExtendedHelp = showExtendedHelp;
 // No environment variables needed for neounzip
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const src_1 = require('../neozipkit-wrappers');
-const server_1 = require('../neozipkit-wrappers/server');
-const blockchain_1 = require('../neozipkit-wrappers/blockchain');
-const Logger_1 = require('../neozipkit-wrappers/core/components/Logger');
-const HashCalculator_1 = __importDefault(require('../neozipkit-wrappers/core/components/HashCalculator'));
+const neozipkit_1 = require("neozipkit");
+const blockchain_1 = require("neozipkit/blockchain");
+const node_1 = __importDefault(require("neozipkit/node"));
 const readline = __importStar(require("readline"));
 const version_1 = require("./version");
 const exit_codes_1 = require("./exit-codes");
@@ -396,7 +394,7 @@ async function pipeArchive(zip, options, filePatterns) {
             });
         });
     }
-    // Apply include/exclude filtering using ZipkitServer.filterEntries()
+    // Apply include/exclude filtering using ZipkitNode.filterEntries()
     const finalEntries = zip.filterEntries(filteredEntries, {
         include: options.include,
         exclude: options.exclude,
@@ -545,15 +543,15 @@ async function testArchive(zip, options) {
     const fileBased = isFileBased(zip);
     const bufferBased = isBufferBased(zip);
     // For merkle root calculation: collect verified SHA-256 hashes during test extraction
-    const hashAccumulator = new HashCalculator_1.default({ enableAccumulation: true });
+    const hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
     let allFilesValid = true;
     const failedFiles = [];
     // Filter out metadata files for merkle root calculation
     const contentEntriesForMerkle = entries.filter(entry => {
         const filename = entry.filename || '';
-        return filename !== src_1.TOKENIZED_METADATA &&
-            filename !== src_1.TIMESTAMP_METADATA &&
-            filename !== src_1.TIMESTAMP_SUBMITTED &&
+        return filename !== neozipkit_1.TOKENIZED_METADATA &&
+            filename !== neozipkit_1.TIMESTAMP_METADATA &&
+            filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
             !entry.isDirectory;
     });
     for (const entry of entries) {
@@ -567,34 +565,26 @@ async function testArchive(zip, options) {
         }
         try {
             if (bufferBased) {
-                // Buffer-based: use extract() which performs CRC/SHA checks
+                // Buffer-based: use extract() which performs CRC/SHA checks and returns data in memory
                 await extractEntry(zip, entry, options.skipBlockchain);
             }
             else if (fileBased) {
-                // File-based: use extractToFile() to a temporary file for testing
-                // extractToFile() performs CRC/SHA checks during extraction
-                const tmpPath = path.join(require('os').tmpdir(), `neounzip-test-${Date.now()}-${entry.filename?.replace(/[^a-zA-Z0-9]/g, '_') || 'file'}`);
-                try {
-                    await zip.extractToFile(entry, tmpPath, {
-                        skipHashCheck: options.skipBlockchain
-                    });
-                    // If extraction succeeds, verification passed (CRC/SHA checks are done during extraction)
-                    // Clean up temporary file
-                    if (fs.existsSync(tmpPath)) {
-                        fs.unlinkSync(tmpPath);
-                    }
-                }
-                catch (extractErr) {
-                    // Clean up temporary file on error
-                    if (fs.existsSync(tmpPath)) {
-                        try {
-                            fs.unlinkSync(tmpPath);
-                        }
-                        catch {
-                            // Ignore cleanup errors
-                        }
+                // File-based: use testEntry() to validate without extracting to disk
+                // testEntry() now returns the verified hash, eliminating the need for temp files
+                const testResult = await zip.testEntry(entry, {
+                    skipHashCheck: options.skipBlockchain
+                });
+                // 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 &&
+                        !entry.isDirectory;
+                    if (isContentFile) {
+                        // Use the verified hash returned from testEntry()
+                        const hashBuffer = Buffer.from(testResult.verifiedHash, 'hex');
+                        hashAccumulator.addHash(hashBuffer);
                     }
-                    throw extractErr;
                 }
             }
             else {
@@ -603,16 +593,6 @@ async function testArchive(zip, options) {
             // Report success
             if (entry.sha256 && !options.skipBlockchain) {
                 console.log(`testing: ${name} ...OK SHA-256`);
-                // Collect verified SHA-256 hash for merkle root calculation (single pass - no double check)
-                const isContentFile = name !== src_1.TOKENIZED_METADATA &&
-                    name !== src_1.TIMESTAMP_METADATA &&
-                    name !== src_1.TIMESTAMP_SUBMITTED &&
-                    !entry.isDirectory;
-                if (isContentFile && entry.sha256) {
-                    // Use the verified hash from the entry (already verified during extraction)
-                    const hashBuffer = Buffer.from(entry.sha256, 'hex');
-                    hashAccumulator.addHash(hashBuffer);
-                }
             }
             else if (entry.sha256 && options.skipBlockchain) {
                 console.log(`testing: ${name} ...OK (SHA-256 skipped)`);
@@ -628,9 +608,9 @@ 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 !== src_1.TOKENIZED_METADATA &&
-                name !== src_1.TIMESTAMP_METADATA &&
-                name !== src_1.TIMESTAMP_SUBMITTED &&
+            const isContentFile = name !== neozipkit_1.TOKENIZED_METADATA &&
+                name !== neozipkit_1.TIMESTAMP_METADATA &&
+                name !== neozipkit_1.TIMESTAMP_SUBMITTED &&
                 !entry.isDirectory;
             if (isEncrypted) {
                 // For encrypted files, decompression errors after decryption usually mean wrong password
@@ -750,7 +730,7 @@ async function preVerifyArchive(zip, archiveName, options) {
     let verificationSuccess = false;
     let verificationError;
     try {
-        const verifier = new src_1.ZipkitVerifier({
+        const verifier = new neozipkit_1.ZipkitVerifier({
             debug: options.verbose,
             skipHash: options.skipBlockchain
         });
@@ -918,7 +898,7 @@ async function extractArchive(zip, destination, options) {
         zip.password = options.password;
     }
     const entries = await getDirectory(zip, false);
-    // Filter entries using ZipkitServer.filterEntries()
+    // Filter entries using ZipkitNode.filterEntries()
     const filteredEntries = zip.filterEntries(entries, {
         include: options.include,
         exclude: options.exclude,
@@ -940,15 +920,15 @@ async function extractArchive(zip, destination, options) {
     let processedFiles = 0;
     const totalEntries = filteredEntries.length;
     // For merkle root calculation: collect verified SHA-256 hashes during extraction
-    const hashAccumulator = new HashCalculator_1.default({ enableAccumulation: true });
+    const hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
     let allFilesValid = true;
     const failedFiles = [];
     // Filter out metadata files for merkle root calculation
     const contentEntriesForMerkle = filteredEntries.filter(entry => {
         const filename = entry.filename || '';
-        return filename !== src_1.TOKENIZED_METADATA &&
-            filename !== src_1.TIMESTAMP_METADATA &&
-            filename !== src_1.TIMESTAMP_SUBMITTED &&
+        return filename !== neozipkit_1.TOKENIZED_METADATA &&
+            filename !== neozipkit_1.TIMESTAMP_METADATA &&
+            filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
             !entry.isDirectory;
     });
     for (const entry of filteredEntries) {
@@ -967,11 +947,11 @@ async function extractArchive(zip, destination, options) {
         if (options.showFiles && !options.quiet) {
             log(`extracting: ${filename}`, options);
         }
-        // Prepare extraction path using ZipkitServer.prepareExtractionPath()
+        // Prepare extraction path using ZipkitNode.prepareExtractionPath()
         const outPath = zip.prepareExtractionPath(entry, destination, {
             junkPaths: options.junkPaths
         });
-        // Determine if entry should be extracted using ZipkitServer.shouldExtractEntry()
+        // Determine if entry should be extracted using ZipkitNode.shouldExtractEntry()
         const shouldExtract = await zip.shouldExtractEntry(entry, outPath, {
             overwrite: options.overwrite || alwaysOverwrite,
             never: options.never,
@@ -999,7 +979,7 @@ async function extractArchive(zip, destination, options) {
             }
             continue;
         }
-        // Extract entry using ZipkitServer.extractEntryToPath()
+        // Extract entry using ZipkitNode.extractEntryToPath()
         const result = await zip.extractEntryToPath(entry, outPath, {
             skipHashCheck: options.skipBlockchain,
             preserveTimestamps: true, // Always preserve timestamps
@@ -1025,9 +1005,9 @@ 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 !== src_1.TOKENIZED_METADATA &&
-                    filename !== src_1.TIMESTAMP_METADATA &&
-                    filename !== src_1.TIMESTAMP_SUBMITTED &&
+                const isContentFile = filename !== neozipkit_1.TOKENIZED_METADATA &&
+                    filename !== neozipkit_1.TIMESTAMP_METADATA &&
+                    filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
                     !entry.isDirectory;
                 if (isContentFile && entry.sha256) {
                     // Use the verified hash from the entry (already verified during extraction)
@@ -1039,9 +1019,9 @@ 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 !== src_1.TOKENIZED_METADATA &&
-                filename !== src_1.TIMESTAMP_METADATA &&
-                filename !== src_1.TIMESTAMP_SUBMITTED &&
+            const isContentFile = filename !== neozipkit_1.TOKENIZED_METADATA &&
+                filename !== neozipkit_1.TIMESTAMP_METADATA &&
+                filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
                 !entry.isDirectory;
             if (isContentFile && !options.skipBlockchain) {
                 // Check if failure was due to SHA-256 mismatch
@@ -1083,7 +1063,7 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
                 return;
             }
             // Initialize blockchain verifier
-            const verifier = new src_1.ZipkitVerifier({
+            const verifier = new neozipkit_1.ZipkitVerifier({
                 debug: options.verbose, // Enable debug output in verbose mode
                 skipHash: options.skipBlockchain
             });
@@ -1171,13 +1151,13 @@ async function verifyTokenization(zip, archiveName, options, extractionResult) {
                 // No pre-calculated result (e.g., list-only mode) - extract files once to calculate merkle root
                 try {
                     console.log('   Calculating merkle root from actual file contents...');
-                    const hashAccumulator = new HashCalculator_1.default({ enableAccumulation: true });
+                    const hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
                     // Filter out blockchain metadata files to ensure consistent Merkle Root calculation
                     const contentEntries = entries.filter(entry => {
                         const filename = entry.filename || '';
-                        return filename !== src_1.TOKENIZED_METADATA &&
-                            filename !== src_1.TIMESTAMP_METADATA &&
-                            filename !== src_1.TIMESTAMP_SUBMITTED &&
+                        return filename !== neozipkit_1.TOKENIZED_METADATA &&
+                            filename !== neozipkit_1.TIMESTAMP_METADATA &&
+                            filename !== neozipkit_1.TIMESTAMP_SUBMITTED &&
                             !entry.isDirectory; // Skip directories
                     });
                     // Extract each file once and verify SHA-256 during extraction
@@ -1540,7 +1520,7 @@ async function verifyAndUpgradeOts(zip, archiveName, options) {
         if (!otsEntry) {
             return;
         }
-        const res = await (0, src_1.verifyOtsZip)(zip);
+        const res = await (0, neozipkit_1.verifyOtsZip)(zip);
         console.log('\n🕐 OpenTimestamps Verification:');
         if (res.status === 'none') {
             console.log(' - Status: No OpenTimestamps found');
@@ -2020,7 +2000,7 @@ async function main() {
         // Use exdir option if provided, otherwise use destination
         const extractDestination = options.exdir || destination;
         // Load the ZIP file
-        zip = new server_1.ZipkitServer();
+        zip = new node_1.default();
         if (options.inMemory) {
             // Use Buffer-based loading (browser compatible)
             const data = fs.readFileSync(archive);
@@ -2048,7 +2028,7 @@ async function main() {
             if (options.debug) {
                 // Set global Logger level to 'debug' for debug output
                 // Note: Individual class logging is controlled by their loggingEnabled static property
-                Logger_1.Logger.setLevel('debug');
+                neozipkit_1.Logger.setLevel('debug');
                 logDebug('Debug mode enabled', options);
                 logDebug(`Command line arguments: ${process.argv.join(' ')}`, options);
                 logDebug(`Working directory: ${process.cwd()}`, options);

package/dist/src/neozip/blockchain.js

@@ -40,16 +40,15 @@ exports.isSupportedNetwork = isSupportedNetwork;
 exports.getWalletPasskey = getWalletPasskey;
 exports.addTokenMetaToZip = addTokenMetaToZip;
 exports.handleTokenMinting = handleTokenMinting;
-const src_1 = require('../../neozipkit-wrappers');
-const blockchain_1 = require('../../neozipkit-wrappers/blockchain');
-const contracts_1 = require('../../neozipkit-wrappers/blockchain/core/contracts');
+const neozipkit_1 = require("neozipkit");
+const blockchain_1 = require("neozipkit/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, contracts_1.getChainIdByName)(network) !== null;
+    return (0, blockchain_1.getChainIdByName)(network) !== null;
 }
 /**
  * Check if the required wallet passkey is available and valid
@@ -95,14 +94,14 @@ 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 = src_1.TOKENIZED_METADATA;
+    const tokenPath = neozipkit_1.TOKENIZED_METADATA;
     // Create new token entry
     const tokenEntry = zip.createZipEntry(tokenPath);
     tokenEntry.timeDateDOS = tokenEntry.setDateTime(new Date());
     tokenEntry.compressedSize = tokenBuffer.length;
     tokenEntry.uncompressedSize = tokenBuffer.length;
     tokenEntry.cmpMethod = 0; // STORED
-    tokenEntry.crc = (0, src_1.crc32)(tokenBuffer);
+    tokenEntry.crc = (0, neozipkit_1.crc32)(tokenBuffer);
     tokenEntry.fileBuffer = tokenBuffer;
     tokenEntry.isUpdated = true;
     console.log('✅ Token metadata prepared for ZIP');
@@ -194,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 src_1.ZipkitMinter(merkleRoot, {
+                    minter = new neozipkit_1.ZipkitMinter(merkleRoot, {
                         network: network,
                         walletPrivateKey: walletPrivateKey,
                         verbose: verbose,
@@ -224,14 +223,19 @@ async function handleTokenMinting(initialMinter, zip, nonInteractive = false, in
                     console.log(`   Contract: ${mintResult.tokenMetadata?.contractAddress}`);
                     // Create TokenMetadata from minting result
                     if (mintResult.tokenMetadata) {
+                        // Determine contract version: v2.11+ has version in config, prior versions are "unknown"
+                        const versionStr = networkConfig?.version || '0';
+                        const versionNum = parseFloat(versionStr);
+                        const contractVersion = versionNum >= 2.11 ? versionStr : 'unknown';
                         const tokenMeta = {
-                            version: '1.0',
+                            contractVersion: contractVersion,
                             tokenId: mintResult.tokenMetadata.tokenId,
                             contractAddress: mintResult.tokenMetadata.contractAddress,
                             network: mintResult.tokenMetadata.network,
                             networkChainId: mintResult.tokenMetadata.networkChainId || networkConfig?.chainId || 84532,
                             transactionHash: mintResult.tokenMetadata.transactionHash,
                             merkleRoot: mintResult.tokenMetadata.merkleRoot,
+                            encryptedHash: mintResult.tokenMetadata.encryptedHash, // Currently unused, but preserve if present
                             mintedAt: mintResult.tokenMetadata.mintDate
                         };
                         // Cleanup before returning