neozip-cli 0.90.0 → 0.95.0

package/dist/src/neozip/createZip.js

@@ -48,12 +48,17 @@ const neozipkit_1 = require("neozipkit");
 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 token_service_1 = require("neozip-blockchain/token-service");
 const CommentManager_1 = require("./CommentManager");
 const utils_1 = require("./utils");
 const file_operations_1 = require("./file-operations");
 const blockchain_1 = require("./blockchain");
-const ConfigStore_1 = require("../config/ConfigStore");
+const cli_guidance_1 = require("../connection/cli-guidance");
+const wallet_login_1 = require("../connection/wallet-login");
+const funding_1 = require("../connection/funding");
+const store_1 = require("../connection/store");
+const cli_prefs_1 = require("../connection/cli-prefs");
+const bootstrap_1 = require("../connection/bootstrap");
 const user_interaction_1 = require("./user-interaction");
 const exit_codes_1 = require("../exit-codes");
 const version_1 = require("../version");
@@ -257,7 +262,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 || this.options.blockchainZipstamp) {
+        if (this.options.blockchain || this.options.blockchainOts || this.options.blockchainTokenService) {
             this.hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
         }
     }
@@ -287,7 +292,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 && !this.options.blockchainZipstamp) {
+        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts && !this.options.blockchainTokenService) {
             const bufferWriter = this.zip.bufferWriter;
             if (bufferWriter) {
                 // Determine if this is a header or data by checking signature
@@ -336,7 +341,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 || this.options.blockchainZipstamp)) {
+            if (!this.options.inMemory || (this.options.blockchain || this.options.blockchainOts || this.options.blockchainTokenService)) {
                 await this.initializeOutput();
             }
             await this.processFiles();
@@ -404,7 +409,7 @@ 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);
-        if (!this.options.blockchainZipstamp && !this.options.blockchainOts) {
+        if (!this.options.blockchainTokenService && !this.options.blockchainOts) {
             (0, utils_1.log)(`🔗 Tokenization: ${this.options.blockchain ? 'enabled' : 'disabled'}`, this.options);
         }
         const encryptionMethod = this.options.encryptionMethod || 'aes256';
@@ -433,15 +438,15 @@ class ZipCreator {
                     (0, utils_1.log)(`Blockchain: enabled (default)`, this.options);
                 }
                 (0, utils_1.log)(`Tokenization: enabled`, this.options);
-                (0, utils_1.log)(`Network: ${this.options.network || 'base-sepolia'}`, this.options);
+                (0, utils_1.log)(`Network: ${(0, cli_prefs_1.resolveNetwork)(this.options.network)}`, this.options);
             }
             else if (this.options.blockchainOts) {
                 (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 if (this.options.blockchainTokenService) {
+                (0, utils_1.log)(`Blockchain: enabled (Token Service)`, this.options);
+                (0, utils_1.log)(`Token Service: enabled`, this.options);
             }
             else {
                 (0, utils_1.log)(`Blockchain: disabled`, this.options);
@@ -821,7 +826,7 @@ class ZipCreator {
         const compressionOptions = {
             level: level,
             useZstd: level === 0 ? false : (this.options.compression || 'zstd') === 'zstd',
-            useSHA256: this.options.blockchain || this.options.blockchainOts || this.options.blockchainZipstamp || false,
+            useSHA256: this.options.blockchain || this.options.blockchainOts || this.options.blockchainTokenService || false,
             password: this.options.encrypt ? this.options.password : null,
             encryptionMethod: (this.options.encryptionMethod === 'pkzip' ? 'zipcrypto' : 'aes256')
         };
@@ -839,7 +844,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 || this.options.blockchainZipstamp;
+            const writeToFile = this.options.blockchain || this.options.blockchainOts || this.options.blockchainTokenService;
             // Create appropriate output writer
             let writer;
             const positionRef = { current: this.currentPosition };
@@ -924,8 +929,8 @@ class ZipCreator {
                         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) {
+                            filename !== token_service_1.SUBMIT_METADATA &&
+                            filename !== token_service_1.TIMESTAMP_METADATA) {
                             const hashBuffer = Buffer.from(entry.sha256, 'hex');
                             this.hashAccumulator.addHash(hashBuffer);
                             if (this.options.verbose) {
@@ -993,8 +998,8 @@ class ZipCreator {
                     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) {
+                        entry.filename === token_service_1.SUBMIT_METADATA ||
+                        entry.filename === token_service_1.TIMESTAMP_METADATA) {
                         zipEntries.splice(index, 1);
                         entryCnt--;
                         index--;
@@ -1076,8 +1081,8 @@ class ZipCreator {
                                     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) {
+                                        filename !== token_service_1.SUBMIT_METADATA &&
+                                        filename !== token_service_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);
@@ -1158,8 +1163,8 @@ class ZipCreator {
             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;
+                filename !== token_service_1.SUBMIT_METADATA &&
+                filename !== token_service_1.TIMESTAMP_METADATA;
         });
         // Add SHA-256 hashes to accumulator
         for (const entry of contentEntries) {
@@ -1176,27 +1181,36 @@ class ZipCreator {
         let tokenMeta = null;
         let tokenInfoEntry = null;
         let otsMetaEntry = null;
-        let zipstampMetaEntry = null;
+        let tokenServiceMetaEntry = 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_1.getWalletPasskey)(this.options.walletKey, false);
+            const connectError = (0, cli_guidance_1.requireConnectionReady)('Blockchain tokenization (-b)', 'wallet');
+            if (connectError) {
+                console.error('❌ Token Service connection not ready');
+                console.error(connectError);
+                if (!this.options.nonInteractive) {
+                    const answer = await (0, user_interaction_1.promptUser)('Continue without blockchain tokenization? (y/n): ');
+                    if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                        this.options.blockchain = false;
+                        this.options.blockchainOts = false;
+                        this.options.blockchainTokenService = false;
+                        return;
+                    }
+                }
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+            }
+            const walletPasskey = (0, blockchain_1.getConnectionWalletKey)(this.options.walletKey, false);
             if (!walletPasskey) {
-                // Show error message and prompt user
                 console.error('\n❌ Error: Wallet private key is required for blockchain operations');
                 console.error('');
-                console.error('   Option 1 (Recommended): Run interactive setup');
-                console.error('   $ neozip init');
+                console.error('   Run: neozip connect');
                 console.error('');
-                console.error('   Option 2: Use command-line flag');
+                console.error('   Or use a one-off override:');
                 console.error('   $ neozip -b -w 0x... <archive> <files>');
                 console.error('');
-                console.error('   Option 3: Set environment variable');
-                console.error('   $ export NEOZIP_WALLET_PASSKEY="0x..."');
-                console.error('');
-                console.error('   Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+                console.error('   Fund your Data Wallet from the Token Service:');
+                console.error('   $ neozip connect fund');
+                console.error('   (or get testnet ETH from https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet)');
                 console.error('');
                 // Prompt user to continue without blockchain tokenization
                 if (!this.options.nonInteractive) {
@@ -1205,18 +1219,18 @@ 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;
+                        this.options.blockchainTokenService = false;
                         return; // Skip tokenization, ZIP is already complete
                     }
                     else {
-                        (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                        (0, utils_1.logError)('💡 Tip: Run "neozip connect" to set up your wallet');
                         (0, utils_1.logError)('💡 Tip: Omit blockchain flags to create ZIP without blockchain operations');
                         (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
                     }
                 }
                 else {
                     // Non-interactive mode - exit with error
-                    (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                    (0, utils_1.logError)('💡 Tip: Run "neozip connect" to set up your wallet');
                     (0, utils_1.logError)('💡 Tip: Omit blockchain flags to create ZIP without blockchain operations');
                     (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
                 }
@@ -1292,9 +1306,13 @@ class ZipCreator {
             if (merkleRoot) {
                 console.log(`\n📋 Merkle Root: ${merkleRoot}`);
                 // Validate network
-                const network = this.options.network || 'base-sepolia';
+                const network = (0, cli_prefs_1.resolveNetwork)(this.options.network);
                 // Always display network when tokenization is enabled
                 console.log(`🌐 Network: ${network}`);
+                const accountEmail = (0, store_1.getActiveConnection)()?.email?.trim();
+                if (accountEmail) {
+                    console.log(`📧 Account: ${accountEmail}`);
+                }
                 // Get network config for contract address and version info
                 const networkConfig = (0, neozip_blockchain_1.getNetworkByName)(network);
                 let contractAddress;
@@ -1343,6 +1361,9 @@ class ZipCreator {
                     ]);
                     console.log(`💳 Wallet: ${processResult.walletInfo.address}`);
                     console.log(`💰 Balance: ${processResult.walletInfo.balance} ETH`);
+                    if ((0, funding_1.isLowWalletBalance)(processResult.walletInfo.balance)) {
+                        console.log(`⚠️  ${(0, funding_1.formatLowBalanceFundingHint)()}`);
+                    }
                     // Network config already retrieved above (contractAddress and networkChainId are available)
                     // Check if tokens already exist for this merkle root
                     if (processResult.duplicateCheck.hasExistingTokens) {
@@ -1606,12 +1627,12 @@ class ZipCreator {
                 }
             }
         }
-        else if (this.options.blockchainZipstamp) {
-            // Handle Zipstamp timestamp for blockchain
+        else if (this.options.blockchainTokenService) {
+            // Handle Token Service timestamp for blockchain
             if (this.options.debug) {
-                (0, utils_1.logDebug)('Zipstamp process starting...', this.options);
+                (0, utils_1.logDebug)('Token Service process starting...', this.options);
             }
-            console.log('🔗 Zipstamp: Creating timestamp proof on blockchain...');
+            console.log('🔗 Token Service: Creating timestamp proof on blockchain...');
             // Calculate merkle root (reuse same logic as OTS)
             let merkleRoot = null;
             if (this.hashAccumulator && this.hashAccumulator.leafCount() > 0) {
@@ -1651,7 +1672,7 @@ class ZipCreator {
                 merkleRoot = this.calculateMerkleRootFromEntries(entriesForMerkle);
             }
             if (!merkleRoot) {
-                console.error('❌ Error calculating merkle root for Zipstamp');
+                console.error('❌ Error calculating merkle root for Token Service');
                 console.error('   Make sure files have been compressed with SHA-256 hashes.');
                 if (this.options.verbose) {
                     const hashCount = this.hashAccumulator ? this.hashAccumulator.leafCount() : 0;
@@ -1664,22 +1685,35 @@ class ZipCreator {
             }
             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)'}`);
+                await (0, wallet_login_1.ensureFreshTokenServiceToken)();
+                const setupError = (0, cli_guidance_1.requireConnectionReady)('Blockchain timestamp (-ts)');
+                if (setupError) {
+                    console.error('❌ Token Service not ready');
+                    console.error(setupError);
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                const tsRuntime = (0, bootstrap_1.getTokenServiceRuntimeOptions)(this.options.verbose);
+                if (!tsRuntime) {
+                    console.error('❌ Token Service credentials missing from connection store');
+                    console.error((0, cli_guidance_1.requireConnectionReady)('Blockchain timestamp (-ts)') ?? 'Run: neozip connect');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+                const recipientEmail = tsRuntime.recipientEmail;
+                const serverUrl = tsRuntime.serverUrl;
+                console.log('🔗 Submitting hash digest to Token Service...');
+                console.log(`   Token Service: ${serverUrl}`);
+                console.log(`📧 Email: ${recipientEmail}`);
                 try {
-                    const zipstampMetadata = await (0, zipstamp_server_1.createTimestamp)(merkleRoot, {
-                        recipientEmail: recipientEmail || undefined,
+                    const tokenServiceMetadata = await (0, token_service_1.createTimestamp)(merkleRoot, {
+                        recipientEmail,
+                        serverUrl,
                         debug: this.options.verbose
                     });
-                    if (!zipstampMetadata) {
-                        throw new Error('Failed to create Zipstamp timestamp');
+                    if (!tokenServiceMetadata) {
+                        throw new Error('Failed to create Token Service timestamp');
                     }
-                    console.log('📄 Zipstamp metadata prepared');
-                    const metaEntry = (0, zipstamp_server_1.createTimestampMetadataEntry)(this.zip, zipstampMetadata);
+                    console.log('📄 Token Service metadata prepared');
+                    const metaEntry = (0, token_service_1.createTimestampMetadataEntry)(this.zip, tokenServiceMetadata);
                     if (metaEntry) {
                         // createTimestampMetadataEntry sets filename based on status (TS-SUBMIT.NZIP or TIMESTAMP.NZIP)
                         metaEntry.cmpMethod = 0; // STORED
@@ -1688,7 +1722,7 @@ class ZipCreator {
                             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');
+                        console.log('✅ Token Service 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.'
@@ -1699,40 +1733,31 @@ class ZipCreator {
                         }
                         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);
+                            (0, utils_1.log)(`📝 Writing Token Service entry: ${metaEntry.filename} at offset ${this.currentPosition}`, this.options);
+                            (0, utils_1.log)(`📊 Token Service entry size: ${metaEntry.fileBuffer?.length || 0} bytes`, this.options);
                         }
                         await this.writeChunk(localHdr);
                         if (metaEntry.fileBuffer) {
                             await this.writeChunk(metaEntry.fileBuffer);
                         }
-                        zipstampMetaEntry = metaEntry;
+                        tokenServiceMetaEntry = metaEntry;
                     }
                     else {
-                        console.warn('⚠️  Warning: Failed to create Zipstamp metadata entry');
+                        console.warn('⚠️  Warning: Failed to create Token Service metadata entry');
                     }
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    console.error('❌ Failed to create Zipstamp proof:', errorMessage);
+                    console.error('❌ Failed to create Token Service 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(`   Email used: ${recipientEmail}`);
                         console.error('');
-                        console.error('   Or use: --timestamp-email <your-verified-email>');
-                        console.error('   Or set: NEOZIP_TIMESTAMP_EMAIL environment variable');
+                        console.error('💡 Token Service requires a verified email. Run:');
+                        console.error('   neozip connect');
                         console.error('');
                     }
                     throw error;
@@ -1742,7 +1767,7 @@ class ZipCreator {
     }
     async finalize() {
         // Check if this is in-memory non-blockchain mode (needs special handling)
-        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts && !this.options.blockchainZipstamp) {
+        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts && !this.options.blockchainTokenService) {
             // 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;
@@ -1905,7 +1930,7 @@ 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) {
+        if (options.blockchainTokenService) {
             (0, utils_1.log)(`   (Validating file integrity only; timestamp not yet confirmed on blockchain)`, options);
         }
         // Import child_process for shelling out
@@ -1916,9 +1941,9 @@ 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.
+            // For Token Service 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) {
+            if (options.blockchainTokenService) {
                 args.push('--skip-blockchain');
             }
             // Add password if encryption is enabled
@@ -1967,8 +1992,8 @@ 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) {
+                    // For Token Service: clarify that timestamp is not validated and not minted
+                    if (options.blockchainTokenService) {
                         (0, utils_1.log)(`   Note: File integrity validated. Timestamp is pending (not yet confirmed on blockchain).`, options);
                     }
                     resolve(true);
@@ -2090,8 +2115,8 @@ async function upgradeZipForTokenization(inputZipPath, options) {
             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 ||
+                filename === token_service_1.SUBMIT_METADATA ||
+                filename === token_service_1.TIMESTAMP_METADATA ||
                 entry.isDirectory) {
                 continue;
             }
@@ -2247,21 +2272,19 @@ 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_1.getWalletPasskey)(options.walletKey, false);
+            const walletPasskey = (0, blockchain_1.getConnectionWalletKey)(options.walletKey, false);
             if (!walletPasskey) {
                 // Show error message and prompt user
                 console.error('❌ Error: Wallet private key is required for blockchain operations');
                 console.error('');
-                console.error('   Option 1 (Recommended): Run interactive setup');
-                console.error('   $ neozip init');
+                console.error('   Run: neozip connect');
                 console.error('');
-                console.error('   Option 2: Use command-line flag');
+                console.error('   Or use a one-off override:');
                 console.error('   $ neozip --upgrade -w 0x... <archive>');
                 console.error('');
-                console.error('   Option 3: Set environment variable');
-                console.error('   $ export NEOZIP_WALLET_PASSKEY="0x..."');
-                console.error('');
-                console.error('   Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+                console.error('   Fund your Data Wallet from the Token Service:');
+                console.error('   $ neozip connect fund');
+                console.error('   (or get testnet ETH from https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet)');
                 console.error('');
                 // Prompt user to continue without blockchain tokenization
                 if (!options.nonInteractive) {
@@ -2271,20 +2294,20 @@ async function upgradeZipForTokenization(inputZipPath, options) {
                         // Skip token minting - ZIP will be upgraded with SHA-256 hashes but no token metadata
                     }
                     else {
-                        (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                        (0, utils_1.logError)('💡 Tip: Run "neozip connect" to set up your wallet');
                         (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR);
                     }
                 }
                 else {
                     // Non-interactive mode - exit with error
-                    (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                    (0, utils_1.logError)('💡 Tip: Run "neozip connect" to set up your wallet');
                     (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR);
                 }
             }
             // Only mint token if wallet passkey is available
             if (walletPasskey) {
                 (0, utils_1.log)(`   Minting new token on blockchain...`, options);
-                const network = options.network || 'base-sepolia';
+                const network = (0, cli_prefs_1.resolveNetwork)(options.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}`);
                 }

package/dist/src/neozip/upgradeZip.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Upgrade Zipstamp timestamp from pending (TS-SUBMIT.NZIP) to confirmed (TIMESTAMP.NZIP)
+ * Upgrade Token Service 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;
@@ -45,15 +45,16 @@ 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 token_service_1 = require("neozip-blockchain/token-service");
 const exit_codes_1 = require("../exit-codes");
+const bootstrap_1 = require("../connection/bootstrap");
 /**
  * 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);
+    let metadata = await (0, token_service_1.extractTimestampData)(zip, entry);
     if (metadata)
         return metadata;
     // Fallback for file-based ZIPs where zip.extract() may not work
@@ -74,7 +75,7 @@ async function extractTimestampMetadata(zip, entry) {
     }
 }
 /**
- * Upgrade a ZIP file with pending Zipstamp timestamp to confirmed status.
+ * Upgrade a ZIP file with pending Token Service 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 = {}) {
@@ -85,9 +86,9 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
     const zip = new node_1.default();
     await zip.loadZipFile(inputPath);
     const entries = zip.getDirectory() || [];
-    const metadataResult = (0, zipstamp_server_1.findMetadataEntry)(entries);
+    const metadataResult = (0, token_service_1.findMetadataEntry)(entries);
     if (!metadataResult) {
-        console.log('No Zipstamp timestamp found in ZIP file');
+        console.log('No Token Service timestamp found in ZIP file');
         return;
     }
     if (metadataResult.type === 'confirmed') {
@@ -98,21 +99,23 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
     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)) {
+    if (!(0, token_service_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;
+    const serverUrl = (0, bootstrap_1.resolveVerifyServerUrl)(metadata.serverUrl);
+    const verifyOpts = { debug, serverUrl };
     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 });
+        verified = await (0, token_service_1.pollForConfirmation)(digest, chainId, batchId, 300000, 5000, verifyOpts);
     }
     else {
-        const verifyRes = await (0, zipstamp_server_1.verifyDigest)(digest, chainId, batchId, undefined, { debug });
+        const verifyRes = await (0, token_service_1.verifyDigest)(digest, chainId, batchId, undefined, verifyOpts);
         if (verifyRes.verified) {
             verified = verifyRes;
         }
@@ -135,7 +138,7 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
         blockNumber: verified.blockNumber ?? metadata.blockNumber,
         timestamp: verified.timestamp ?? metadata.timestamp
     };
-    const metadataFiles = (0, zipstamp_server_1.getMetadataFileNames)();
+    const metadataFiles = (0, token_service_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`);
@@ -144,7 +147,7 @@ async function upgradeZipForTimestamp(inputPath, outputPath, options = {}) {
         const { destPath, dataEndOffset, copiedEntries } = await zipCopy.copyZipEntriesOnly(inputPath, tempPath, {
             entryFilter: (entry) => !metadataFiles.includes(entry.filename || '')
         });
-        const newEntry = (0, zipstamp_server_1.createTimestampMetadataEntry)(zip, confirmedMetadata);
+        const newEntry = (0, token_service_1.createTimestampMetadataEntry)(zip, confirmedMetadata);
         if (!newEntry) {
             throw new Error('Failed to create timestamp metadata entry');
         }