neozip-cli 0.75.2-beta → 0.90.0

package/dist/src/commands/mintTimestampProof.js

@@ -0,0 +1,335 @@
+"use strict";
+/**
+ * Mint TimestampProofNFT from a confirmed timestamped ZIP (TIMESTAMP.NZIP)
+ *
+ * Creates TOKEN.NZIP metadata and outputs a new ZIP with NFT proof.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMintTimestampProof = runMintTimestampProof;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const ethers_1 = require("ethers");
+const node_1 = __importDefault(require("neozipkit/node"));
+const node_2 = require("neozipkit/node");
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const neozip_blockchain_1 = require("neozip-blockchain");
+const blockchain_1 = require("../neozip/blockchain");
+const RPC_BY_CHAIN = {
+    84532: 'https://sepolia.base.org',
+    421614: 'https://sepolia-rollup.arbitrum.io/rpc',
+    11155111: 'https://ethereum-sepolia-rpc.publicnode.com',
+    8453: 'https://mainnet.base.org',
+    42161: 'https://arb1.arbitrum.io/rpc',
+    1: 'https://eth.llamarpc.com',
+};
+/** Get a single string from an error so we can reliably detect "already minted" (ethers v6 puts reason in error.reason). */
+function getErrorMessage(error) {
+    if (error == null)
+        return '';
+    const e = error;
+    const parts = [];
+    if (typeof e.reason === 'string')
+        parts.push(e.reason);
+    if (typeof e.message === 'string')
+        parts.push(e.message);
+    if (parts.length === 0)
+        parts.push(String(error));
+    return parts.join(' ');
+}
+/**
+ * Run the mint flow: load ZIP, extract TIMESTAMP.NZIP, prepare mint, mint NFT, create output ZIP with TOKEN.NZIP
+ */
+async function runMintTimestampProof(options) {
+    const { inputPath, outputPath, walletKey: cliWalletKey, debug = false } = options;
+    if (!fs.existsSync(inputPath)) {
+        console.error(`Error: ZIP file not found: ${inputPath}`);
+        return false;
+    }
+    const walletKey = (0, blockchain_1.getWalletPasskey)(cliWalletKey, true);
+    if (!walletKey) {
+        return false;
+    }
+    const zip = new node_1.default();
+    await zip.loadZipFile(inputPath);
+    const entries = zip.getDirectory() || [];
+    const metadataResult = (0, zipstamp_server_1.findMetadataEntry)(entries);
+    if (!metadataResult) {
+        console.error('No Zipstamp timestamp found in ZIP file');
+        return false;
+    }
+    if (metadataResult.type !== 'confirmed') {
+        console.error('Archive must have confirmed timestamp (TIMESTAMP.NZIP). Run "neozip upgrade <archive>" first.');
+        return false;
+    }
+    let timestampMetadata = await (0, zipstamp_server_1.extractTimestampData)(zip, metadataResult.entry);
+    if (!timestampMetadata || !timestampMetadata.digest) {
+        // Fallback for file-based ZIPs where zip.extract() may not work
+        try {
+            const tmpPath = path.join(os.tmpdir(), `neozip-mint-meta-${Date.now()}.json`);
+            await zip.extractToFile(metadataResult.entry, tmpPath, { skipHashCheck: true });
+            try {
+                const buf = fs.readFileSync(tmpPath);
+                timestampMetadata = JSON.parse(buf.toString('utf-8'));
+            }
+            finally {
+                if (fs.existsSync(tmpPath))
+                    fs.unlinkSync(tmpPath);
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    if (!timestampMetadata || !timestampMetadata.digest) {
+        console.error('Failed to extract timestamp metadata');
+        return false;
+    }
+    const chainId = timestampMetadata.chainId ?? 84532;
+    const batchId = timestampMetadata.batchId ?? undefined;
+    console.log('Checking NFT status...');
+    const nftStatus = await (0, zipstamp_server_1.checkNFTStatus)(timestampMetadata.digest, chainId, { debug });
+    if (nftStatus.isMinted && nftStatus.tokenId) {
+        console.log(`Digest already minted as token #${nftStatus.tokenId}`);
+        console.log('Proceeding to create TOKEN.NZIP with existing token data...');
+    }
+    console.log('Preparing mint data...');
+    const prepareResult = await (0, zipstamp_server_1.prepareMint)(timestampMetadata.digest, chainId, batchId, { debug });
+    if (!prepareResult.success || !prepareResult.mintData) {
+        console.error(`Error: ${prepareResult.error || 'Failed to prepare mint data'}`);
+        return false;
+    }
+    const mintData = prepareResult.mintData;
+    let tokenId;
+    let mintTransactionHash;
+    let mintBlockNumber;
+    let ownerAddress;
+    if (nftStatus.isMinted && nftStatus.tokenId) {
+        tokenId = nftStatus.tokenId;
+        ownerAddress = nftStatus.owner || 'unknown';
+        mintTransactionHash = 'already-minted';
+        mintBlockNumber = 0;
+    }
+    else {
+        const rpcUrl = RPC_BY_CHAIN[chainId] ?? (0, neozip_blockchain_1.getContractConfig)(chainId)?.rpcUrls?.[0];
+        if (!rpcUrl) {
+            console.error(`Error: No RPC URL for chain ID ${chainId}`);
+            return false;
+        }
+        const provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl, chainId);
+        const wallet = new ethers_1.ethers.Wallet(walletKey.startsWith('0x') ? walletKey : `0x${walletKey}`, provider);
+        ownerAddress = wallet.address;
+        const balance = await provider.getBalance(wallet.address);
+        const mintFeeWei = BigInt(mintData.mintFeeWei);
+        if (balance < mintFeeWei) {
+            console.error(`Error: Insufficient balance. Required: ${mintData.mintFee} ETH`);
+            return false;
+        }
+        const nftContract = new ethers_1.ethers.Contract(mintData.nftContractAddress, neozip_blockchain_1.NZIP_CONTRACT_ABI_V250, wallet);
+        console.log('Minting NFT...');
+        try {
+            const tx = await nftContract.mintWithTimestampProof(mintData.digest, mintData.merkleProof, mintData.batchMerkleRoot, { value: mintFeeWei });
+            const receipt = await tx.wait();
+            if (!receipt || receipt.status !== 1) {
+                throw new Error('Transaction failed');
+            }
+            mintTransactionHash = receipt.hash;
+            mintBlockNumber = receipt.blockNumber;
+            tokenId = '0';
+            for (const eventLog of receipt.logs) {
+                try {
+                    const parsed = nftContract.interface.parseLog({
+                        topics: eventLog.topics,
+                        data: eventLog.data,
+                    });
+                    if (parsed?.name === 'TimestampProofMinted') {
+                        tokenId = parsed.args.tokenId.toString();
+                        break;
+                    }
+                }
+                catch {
+                    /* skip */
+                }
+            }
+            console.log(`Token minted: #${tokenId}`);
+        }
+        catch (error) {
+            const msg = getErrorMessage(error);
+            const isAlreadyMinted = /already minted/i.test(msg);
+            if (isAlreadyMinted) {
+                console.log('Contract reports digest already minted; resolving existing token...');
+                let existingTokenId;
+                let existingOwner;
+                let existingBlockNumber;
+                const existingStatus = await (0, zipstamp_server_1.checkNFTStatus)(timestampMetadata.digest, chainId, { debug });
+                if (existingStatus.isMinted && existingStatus.tokenId) {
+                    existingTokenId = existingStatus.tokenId;
+                    existingOwner = existingStatus.owner;
+                    existingBlockNumber = existingStatus.proofData?.batchBlockNumber;
+                }
+                if (!existingTokenId) {
+                    const verifyRes = await (0, zipstamp_server_1.verifyDigest)(timestampMetadata.digest, chainId, batchId ?? undefined, undefined, { debug });
+                    if (verifyRes.verified && verifyRes.tokenId) {
+                        existingTokenId = verifyRes.tokenId;
+                        existingOwner = verifyRes.owner;
+                        existingBlockNumber = verifyRes.blockNumber;
+                    }
+                }
+                if (existingTokenId) {
+                    tokenId = existingTokenId;
+                    ownerAddress = existingOwner ?? 'unknown';
+                    mintTransactionHash = 'already-minted';
+                    mintBlockNumber = existingBlockNumber ?? 0;
+                    console.log(`Using existing token #${tokenId}. Creating TOKEN.NZIP...`);
+                }
+                else {
+                    console.error('Mint failed: digest is already minted on-chain but token details could not be retrieved. Try the Zipstamp server or block explorer for this digest.');
+                    console.error(`Details: ${msg}`);
+                    return false;
+                }
+            }
+            else {
+                console.error(`Mint failed: ${msg}`);
+                return false;
+            }
+        }
+    }
+    const nftMetadata = {
+        tokenId,
+        contractAddress: mintData.nftContractAddress,
+        network: mintData.network,
+        merkleRoot: mintData.digest,
+        networkChainId: chainId,
+        contractVersion: mintData.contractVersion,
+        transactionHash: mintTransactionHash,
+        blockNumber: mintBlockNumber,
+        owner: ownerAddress,
+        mintedAt: new Date().toISOString(),
+        timestampProof: {
+            digest: mintData.digest,
+            merkleProof: mintData.merkleProof,
+            batchMerkleRoot: mintData.batchMerkleRoot,
+            batchNumber: mintData.batchNumber,
+            batchTransactionHash: mintData.batchTransactionHash,
+            batchBlockNumber: mintData.batchBlockNumber,
+            batchTimestamp: mintData.batchTimestamp,
+            registryAddress: mintData.registryAddress,
+            nftContractAddress: mintData.nftContractAddress,
+            serverUrl: (0, zipstamp_server_1.getZipStampServerUrl)(),
+        },
+    };
+    const metadataFiles = (0, zipstamp_server_1.getMetadataFileNames)();
+    const outPath = outputPath ?? inputPath.replace(/(\.nzip|\.zip)$/i, '-nft$1');
+    const tempDir = path.dirname(outPath) || '.';
+    const tempPath = path.join(tempDir, `.neozip-mint-${Date.now()}.tmp`);
+    try {
+        const zipCopy = new node_2.ZipCopyNode(new node_1.default());
+        const { destPath, dataEndOffset, copiedEntries } = await zipCopy.copyZipEntriesOnly(inputPath, tempPath, {
+            entryFilter: (entry) => !metadataFiles.includes(entry.filename || ''),
+        });
+        const tokenContent = JSON.stringify(nftMetadata, null, 2);
+        const tokenBuffer = Buffer.from(tokenContent, 'utf-8');
+        const { crc32 } = await import('neozipkit');
+        const tokenEntry = zip.createZipEntry('META-INF/TOKEN.NZIP');
+        tokenEntry.crc = crc32(tokenBuffer) >>> 0;
+        tokenEntry.compressedSize = tokenBuffer.length;
+        tokenEntry.uncompressedSize = tokenBuffer.length;
+        tokenEntry.cmpMethod = 0;
+        tokenEntry.localHdrOffset = dataEndOffset;
+        tokenEntry.fileBuffer = tokenBuffer;
+        const localHdr = tokenEntry.createLocalHdr();
+        const fd = fs.openSync(destPath, 'r+');
+        try {
+            fs.writeSync(fd, localHdr, 0, localHdr.length, dataEndOffset);
+            fs.writeSync(fd, tokenBuffer, 0, tokenBuffer.length, dataEndOffset + localHdr.length);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        const allEntries = [...copiedEntries, tokenEntry];
+        zipCopy.writeCentralDirectoryAndEOCD(destPath, allEntries, { zipComment: '' });
+        fs.renameSync(destPath, outPath);
+        console.log(`Output: ${outPath}`);
+        // Summary matching Zipstamp verification style
+        console.log('\n🔗 Mint complete:');
+        console.log(' - Status: ✅ MINTED');
+        console.log(' - Stamp type: NZIP-NFT (tokenized archive)');
+        console.log(` - Token ID: #${tokenId}`);
+        console.log(` - Network: ${mintData.network}`);
+        console.log(` - Contract: ${mintData.nftContractAddress}`);
+        if (mintTransactionHash && mintTransactionHash !== 'already-minted') {
+            console.log(` - Transaction: ${mintTransactionHash}`);
+        }
+        if (mintBlockNumber > 0) {
+            console.log(` - Block: ${mintBlockNumber}`);
+        }
+        const batchTs = mintData.batchTimestamp;
+        if (batchTs != null && mintBlockNumber > 0) {
+            const ts = typeof batchTs === 'number' ? (batchTs < 1e12 ? batchTs * 1000 : batchTs) : Date.parse(String(batchTs));
+            if (!isNaN(ts)) {
+                const blockDate = new Date(ts);
+                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}`);
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        if (fs.existsSync(tempPath)) {
+            try {
+                fs.unlinkSync(tempPath);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`Error creating output: ${msg}`);
+        return false;
+    }
+}
+//# sourceMappingURL=mintTimestampProof.js.map

package/dist/src/commands/verifyEmail.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Verify email for Zipstamp timestamping
+ *
+ * Sets a default email for Zipstamp timestamps. Checks with the server whether
+ * the email is already verified; if not, sends a magic link. Always saves as default.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifyEmail = runVerifyEmail;
+const readline = __importStar(require("readline"));
+const zipstamp_server_1 = require("neozip-blockchain/zipstamp-server");
+const ConfigStore_1 = require("../config/ConfigStore");
+const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmail(email) {
+    return EMAIL_REGEX.test(email.trim());
+}
+function isAlreadyVerifiedMessage(msg) {
+    if (!msg)
+        return false;
+    const lower = msg.toLowerCase();
+    return ((lower.includes('already') && (lower.includes('verified') || lower.includes('registered'))) ||
+        lower.includes('already verified') ||
+        lower.includes('email already'));
+}
+/**
+ * Run the verify-email flow.
+ * Calls the server to check verification status; if already verified, sets as default.
+ * If not, sends magic link and sets as default. Always saves email to config.
+ */
+async function runVerifyEmail(options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const prompt = (question, defaultValue) => {
+        return new Promise((resolve) => {
+            const display = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+            rl.question(display, (answer) => {
+                resolve((answer.trim() || defaultValue || '').trim());
+            });
+        });
+    };
+    try {
+        console.log('\n📧 Zipstamp Email Configuration\n');
+        console.log('Zipstamp requires a verified email to create timestamped ZIP files.');
+        console.log('');
+        const config = ConfigStore_1.ConfigStore.getConfig();
+        const defaultEmail = options?.email || config.timestampEmail || '';
+        const email = await prompt('Email address', defaultEmail || undefined);
+        if (!email) {
+            console.error('❌ Email is required');
+            rl.close();
+            return false;
+        }
+        if (!isValidEmail(email)) {
+            console.error('❌ Invalid email format');
+            rl.close();
+            return false;
+        }
+        // --set-default: skip server check, just save
+        if (options?.setDefaultOnly) {
+            const saved = ConfigStore_1.ConfigStore.set('zipstamp.timestampEmail', email);
+            if (!saved) {
+                console.error('❌ Failed to save email to configuration');
+                rl.close();
+                return false;
+            }
+            console.log(`\n✅ ${email} set as default for Zipstamp timestamps.`);
+            console.log('\n💡 You can now create timestamped ZIPs: neozip -ts <archive> <files>\n');
+            rl.close();
+            return true;
+        }
+        // Check with server: register returns status (already verified vs magic link sent)
+        console.log(`\n📤 Checking verification status for ${email}...`);
+        const registerResult = await (0, zipstamp_server_1.registerEmail)(email, {
+            debug: options?.debug,
+        });
+        if (!registerResult.success) {
+            console.error('❌ Failed to register email:', registerResult.error || 'Unknown error');
+            rl.close();
+            return false;
+        }
+        const res = registerResult;
+        const msg = res.message || '';
+        const alreadyVerified = res.verified === true ||
+            res.alreadyVerified === true ||
+            isAlreadyVerifiedMessage(msg);
+        const saved = ConfigStore_1.ConfigStore.set('zipstamp.timestampEmail', email);
+        if (!saved) {
+            console.error('❌ Failed to save email to configuration');
+            rl.close();
+            return false;
+        }
+        if (alreadyVerified) {
+            console.log('\n✅ Email is already verified. Set as default.');
+        }
+        else {
+            console.log('\n✅ Verification link sent. Check your inbox (and spam folder).');
+            console.log('   Click the magic link in the email to complete verification.');
+            console.log(`   ${email} has been set as default and will work once you've clicked the link.`);
+        }
+        console.log('\n💡 You can now create timestamped ZIPs: neozip -ts <archive> <files>\n');
+        rl.close();
+        return true;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error('❌ Error:', msg);
+        rl.close();
+        return false;
+    }
+}
+//# sourceMappingURL=verifyEmail.js.map

package/dist/src/config/ConfigSetup.js

@@ -41,7 +41,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigSetup = void 0;
 const readline = __importStar(require("readline"));
 const ConfigStore_1 = require("./ConfigStore");
-const blockchain_1 = require("neozipkit/blockchain");
+const neozip_blockchain_1 = require("neozip-blockchain");
+function resolveScriptPath(jsPath) {
+    if (typeof __filename !== 'undefined' && __filename.endsWith('.ts')) {
+        return jsPath.replace(/\.js$/, '.ts');
+    }
+    return jsPath;
+}
 class ConfigSetup {
     constructor() {
         this.rl = readline.createInterface({
@@ -148,7 +154,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(blockchain_1.CONTRACT_CONFIGS);
+            const networkConfigs = Object.values(neozip_blockchain_1.CONTRACT_CONFIGS);
             // Verify we're loading networks
             if (networkConfigs.length === 0) {
                 console.error('❌ Error: No networks found in CONTRACT_CONFIGS');
@@ -160,7 +166,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, blockchain_1.normalizeNetworkName)(config.network);
+                    : (0, neozip_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 +194,7 @@ class ConfigSetup {
             }
             if (useCustomRpc === 'y') {
                 // Get the selected network config to show default RPC
-                const selectedNetworkConfig = (0, blockchain_1.getNetworkByName)(network);
+                const selectedNetworkConfig = (0, neozip_blockchain_1.getNetworkByName)(network);
                 // Prompt for RPC URL for the selected network
                 if (selectedNetworkConfig) {
                     const defaultRpc = selectedNetworkConfig.rpcUrls && selectedNetworkConfig.rpcUrls.length > 0
@@ -197,12 +203,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, blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network);
+                        : (0, neozip_blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network);
                     // Check both new format and legacy format for backward compatibility
                     const existingRpc = rpcConfig[rpcKey]
-                        || rpcConfig[(0, blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')]
+                        || rpcConfig[(0, neozip_blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')]
                         || existingConfig?.rpc?.[rpcKey]
-                        || existingConfig?.rpc?.[(0, blockchain_1.normalizeNetworkName)(selectedNetworkConfig.network).replace(/\s+/g, '')];
+                        || existingConfig?.rpc?.[(0, neozip_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 +224,21 @@ class ConfigSetup {
                         // Skip the already configured network
                         const configAlias = config.nameAliases && config.nameAliases.length > 0
                             ? config.nameAliases[0]
-                            : (0, blockchain_1.normalizeNetworkName)(config.network);
+                            : (0, neozip_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, blockchain_1.normalizeNetworkName)(config.network);
+                            : (0, neozip_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, blockchain_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')]
+                            || rpcConfig[(0, neozip_blockchain_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')]
                             || existingConfig?.rpc?.[rpcKey]
-                            || existingConfig?.rpc?.[(0, blockchain_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')];
+                            || existingConfig?.rpc?.[(0, neozip_blockchain_1.normalizeNetworkName)(config.network).replace(/\s+/g, '')];
                         const customRpc = await this.prompt(`   ${config.network} RPC URL`, existingRpc || defaultRpc);
                         if (customRpc) {
                             rpcConfig[rpcKey] = customRpc;
@@ -274,12 +280,29 @@ class ConfigSetup {
                 verbose = verboseStr === 'y';
                 debugEnabled = debugStr === 'y';
             }
-            // Build configuration object
+            // 6. Zipstamp Email (optional - for timestamped ZIPs)
+            console.log('\n6️⃣  Zipstamp Email (optional)');
+            const configureZipstamp = await this.promptSelection('Configure email for Zipstamp timestamping?', [
+                { value: 'n', label: 'No', description: 'Skip - run neozip verify-email later if needed' },
+                { value: 'y', label: 'Yes', description: 'Set email (must verify with neozip verify-email)' }
+            ], 'n');
+            let zipstampEmail;
+            if (configureZipstamp === 'y') {
+                zipstampEmail = await this.prompt('   Zipstamp timestamp email', existingConfig?.zipstamp?.timestampEmail || '');
+                if (zipstampEmail) {
+                    console.log('   💡 Run "neozip verify-email" to verify this email before creating timestamped ZIPs.');
+                }
+            }
+            // Build configuration object (preserve existing zipstamp if not configuring)
+            const zipstampConfig = zipstampEmail !== undefined
+                ? (zipstampEmail ? { timestampEmail: zipstampEmail } : undefined)
+                : existingConfig?.zipstamp;
             const config = {
                 wallet: {
                     privateKey,
                     network,
                 },
+                zipstamp: zipstampConfig,
                 rpc: Object.keys(rpcConfig).length > 0 ? rpcConfig : undefined,
                 gas: gasMultiplier || maxGasPrice ? {
                     multiplier: gasMultiplier,
@@ -343,16 +366,17 @@ class ConfigSetup {
                 const hasPrivateKey = config.walletKey !== null;
                 console.log('What would you like to do?');
                 console.log('  1. Modify configuration (update settings)');
+                console.log('  2. Verify Zipstamp email (for timestamped ZIPs)');
                 if (hasPrivateKey) {
-                    console.log('  2. Delete private key (remove wallet key from configuration)');
-                    console.log('  3. Reset to defaults (delete entire configuration)');
-                    console.log('  4. Exit');
+                    console.log('  3. Delete private key (remove wallet key from configuration)');
+                    console.log('  4. Reset to defaults (delete entire configuration)');
+                    console.log('  5. Exit');
                 }
                 else {
-                    console.log('  2. Reset to defaults (delete entire configuration)');
-                    console.log('  3. Exit');
+                    console.log('  3. Reset to defaults (delete entire configuration)');
+                    console.log('  4. Exit');
                 }
-                const maxChoice = hasPrivateKey ? 4 : 3;
+                const maxChoice = hasPrivateKey ? 5 : 4;
                 rl.question(`\nEnter choice (1-${maxChoice}): `, async (answer) => {
                     const choice = parseInt(answer);
                     switch (choice) {
@@ -363,6 +387,12 @@ class ConfigSetup {
                             process.exit(success ? 0 : 1);
                             break;
                         case 2:
+                            rl.close();
+                            const { runVerifyEmail } = await import(resolveScriptPath('../commands/verifyEmail.js'));
+                            const verifySuccess = await runVerifyEmail();
+                            process.exit(verifySuccess ? 0 : 1);
+                            break;
+                        case 3:
                             if (hasPrivateKey) {
                                 // Delete private key only
                                 rl.question('\n⚠️  Are you sure you want to delete your private key? (y/n): ', (confirm) => {
@@ -403,7 +433,7 @@ class ConfigSetup {
                                 });
                             }
                             break;
-                        case 3:
+                        case 4:
                             if (hasPrivateKey) {
                                 // Reset entire config
                                 rl.question('\n⚠️  Are you sure you want to delete your wallet configuration? (y/n): ', (confirm) => {
@@ -429,7 +459,7 @@ class ConfigSetup {
                                 process.exit(0);
                             }
                             break;
-                        case 4:
+                        case 5:
                             if (hasPrivateKey) {
                                 // Exit
                                 console.log('');