neozip-cli 0.70.0-alpha → 0.75.0-beta

package/dist/neozipkit-bundles/blockchain.js

@@ -26,9 +26,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// neozipkit/dist/types/index.js
+// node_modules/neozipkit/dist/types/index.js
 var require_types = __commonJS({
-  "neozipkit/dist/types/index.js"(exports2) {
+  "node_modules/neozipkit/dist/types/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.NEOZIPKIT_INFO = exports2.NETWORKS = void 0;
@@ -65,9 +65,286 @@ var require_types = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/core/contracts.js
+// node_modules/neozipkit/dist/blockchain/core/ContractVersionRegistry.js
+var require_ContractVersionRegistry = __commonJS({
+  "node_modules/neozipkit/dist/blockchain/core/ContractVersionRegistry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.IMPLEMENTED_VERSIONS = exports2.VERSION_REGISTRY = void 0;
+    exports2.getVersionCapabilities = getVersionCapabilities;
+    exports2.isVersionSupported = isVersionSupported;
+    exports2.normalizeVersion = normalizeVersion;
+    exports2.getSupportedVersions = getSupportedVersions;
+    exports2.VERSION_REGISTRY = {
+      "2.0": {
+        supportsEncryptedHash: false,
+        supportsFileName: true,
+        getZipFileInfoFields: ["fileName", "merkleRootHash", "ipfsHash", "creator", "creationTimestamp", "tokenizationTime", "blockNumber"],
+        publicMintZipFileSignature: "v2.0",
+        hasGetVersion: true,
+        additionalFunctions: []
+      },
+      "2.10": {
+        supportsEncryptedHash: false,
+        supportsFileName: false,
+        getZipFileInfoFields: ["merkleRootHash", "ipfsHash", "creator", "creationTimestamp", "tokenizationTime", "blockNumber"],
+        publicMintZipFileSignature: "v2.10",
+        hasGetVersion: true,
+        additionalFunctions: []
+      },
+      "2.11": {
+        supportsEncryptedHash: true,
+        supportsFileName: false,
+        getZipFileInfoFields: ["merkleRootHash", "encryptedHash", "ipfsHash", "creator", "creationTimestamp", "tokenizationTime", "blockNumber"],
+        publicMintZipFileSignature: "v2.11",
+        hasGetVersion: true,
+        additionalFunctions: ["getEncryptedHash", "verifyEncryptedZipFile"]
+      }
+    };
+    function getVersionCapabilities(version) {
+      const normalizedVersion = normalizeVersion(version);
+      if (normalizedVersion in exports2.VERSION_REGISTRY) {
+        return exports2.VERSION_REGISTRY[normalizedVersion];
+      }
+      return null;
+    }
+    __name(getVersionCapabilities, "getVersionCapabilities");
+    exports2.IMPLEMENTED_VERSIONS = ["2.10", "2.11"];
+    function isVersionSupported(version) {
+      const normalized = normalizeVersion(version);
+      if (!normalized) {
+        return false;
+      }
+      return getVersionCapabilities(normalized) !== null && exports2.IMPLEMENTED_VERSIONS.includes(normalized);
+    }
+    __name(isVersionSupported, "isVersionSupported");
+    function normalizeVersion(version) {
+      if (!version || version === "unknown" || version.trim() === "") {
+        return "";
+      }
+      const parts = version.split(".");
+      if (parts.length >= 2) {
+        return `${parts[0]}.${parts[1]}`;
+      }
+      return version;
+    }
+    __name(normalizeVersion, "normalizeVersion");
+    function getSupportedVersions() {
+      return Object.keys(exports2.VERSION_REGISTRY);
+    }
+    __name(getSupportedVersions, "getSupportedVersions");
+  }
+});
+
+// node_modules/neozipkit/dist/blockchain/core/adapters/V2_10Adapter.js
+var require_V2_10Adapter = __commonJS({
+  "node_modules/neozipkit/dist/blockchain/core/adapters/V2_10Adapter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.V2_10Adapter = void 0;
+    var ethers_1 = require("ethers");
+    var V2_10_ABI = [
+      "function publicMintZipFile(string memory merkleRootHash, uint256 creationTimestamp, string memory ipfsHash, string memory metadataURI) public returns (uint256)",
+      "function getZipFileInfo(uint256 tokenId) external view returns (tuple(string merkleRootHash, string ipfsHash, address creator, uint256 creationTimestamp, uint256 tokenizationTime, uint256 blockNumber))",
+      "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
+    ];
+    var iface = new ethers_1.Interface(V2_10_ABI);
+    var V2_10Adapter = class {
+      static {
+        __name(this, "V2_10Adapter");
+      }
+      constructor() {
+        this.version = "2.10";
+      }
+      async mintZipFile(contract, merkleRoot, encryptedHash, creationTimestamp, ipfsHash, metadataURI, gasOptions) {
+        if (encryptedHash) {
+          console.warn("[V2_10Adapter] encryptedHash provided but v2.10 contract does not support it - ignoring");
+        }
+        const contractTyped = contract;
+        const args = [
+          merkleRoot,
+          creationTimestamp,
+          ipfsHash,
+          metadataURI
+        ];
+        if (gasOptions) {
+          return await contractTyped.publicMintZipFile(...args, gasOptions);
+        }
+        return await contractTyped.publicMintZipFile(...args);
+      }
+      async getZipFileInfo(contract, tokenId) {
+        const contractTyped = contract;
+        const runner = contractTyped.runner || contractTyped.provider;
+        const adapterContract = new ethers_1.Contract(contractTyped.target, V2_10_ABI, runner);
+        const result = await adapterContract.getZipFileInfo(tokenId);
+        return {
+          merkleRootHash: result[0],
+          ipfsHash: result[1],
+          creator: result[2],
+          creationTimestamp: result[3],
+          tokenizationTime: result[4],
+          blockNumber: result[5]
+          // encryptedHash and fileName not available in v2.10
+        };
+      }
+      parseZipFileTokenizedEvent(log) {
+        const parsed = iface.parseLog({
+          topics: log.topics,
+          data: log.data
+        });
+        if (!parsed || parsed.name !== "ZipFileTokenized") {
+          throw new Error("Invalid ZipFileTokenized event");
+        }
+        return {
+          tokenId: parsed.args.tokenId,
+          creator: parsed.args.creator,
+          merkleRootHash: parsed.args.merkleRootHash,
+          creationTimestamp: parsed.args.creationTimestamp,
+          ipfsHash: parsed.args.ipfsHash,
+          tokenizationTime: parsed.args.tokenizationTime,
+          blockNumber: parsed.args.blockNumber
+          // encryptedHash and fileName not in v2.10 event
+        };
+      }
+      async estimateGasForMint(contract, merkleRoot, encryptedHash, creationTimestamp, ipfsHash, metadataURI) {
+        const contractTyped = contract;
+        return await contractTyped.publicMintZipFile.estimateGas(merkleRoot, creationTimestamp, ipfsHash, metadataURI);
+      }
+    };
+    exports2.V2_10Adapter = V2_10Adapter;
+  }
+});
+
+// node_modules/neozipkit/dist/blockchain/core/adapters/V2_11Adapter.js
+var require_V2_11Adapter = __commonJS({
+  "node_modules/neozipkit/dist/blockchain/core/adapters/V2_11Adapter.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.V2_11Adapter = void 0;
+    var ethers_1 = require("ethers");
+    var V2_11_ABI = [
+      "function publicMintZipFile(string memory merkleRootHash, string memory encryptedHash, uint256 creationTimestamp, string memory ipfsHash, string memory metadataURI) public returns (uint256)",
+      "function getZipFileInfo(uint256 tokenId) external view returns (tuple(string merkleRootHash, string encryptedHash, string ipfsHash, address creator, uint256 creationTimestamp, uint256 tokenizationTime, uint256 blockNumber))",
+      "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string merkleRootHash, string encryptedHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
+    ];
+    var iface = new ethers_1.Interface(V2_11_ABI);
+    var V2_11Adapter = class {
+      static {
+        __name(this, "V2_11Adapter");
+      }
+      constructor() {
+        this.version = "2.11";
+      }
+      async mintZipFile(contract, merkleRoot, encryptedHash, creationTimestamp, ipfsHash, metadataURI, gasOptions) {
+        const contractTyped = contract;
+        const args = [
+          merkleRoot,
+          encryptedHash || "",
+          creationTimestamp,
+          ipfsHash,
+          metadataURI
+        ];
+        if (gasOptions) {
+          return await contractTyped.publicMintZipFile(...args, gasOptions);
+        }
+        return await contractTyped.publicMintZipFile(...args);
+      }
+      async getZipFileInfo(contract, tokenId) {
+        const contractTyped = contract;
+        const runner = contractTyped.runner || contractTyped.provider;
+        const adapterContract = new ethers_1.Contract(contractTyped.target, V2_11_ABI, runner);
+        const result = await adapterContract.getZipFileInfo(tokenId);
+        return {
+          merkleRootHash: result[0],
+          encryptedHash: result[1] || void 0,
+          // May be empty string
+          ipfsHash: result[2],
+          creator: result[3],
+          creationTimestamp: result[4],
+          tokenizationTime: result[5],
+          blockNumber: result[6]
+          // fileName not available in v2.11
+        };
+      }
+      parseZipFileTokenizedEvent(log) {
+        const parsed = iface.parseLog({
+          topics: log.topics,
+          data: log.data
+        });
+        if (!parsed || parsed.name !== "ZipFileTokenized") {
+          throw new Error("Invalid ZipFileTokenized event");
+        }
+        return {
+          tokenId: parsed.args.tokenId,
+          creator: parsed.args.creator,
+          merkleRootHash: parsed.args.merkleRootHash,
+          encryptedHash: parsed.args.encryptedHash || void 0,
+          // May be empty string
+          creationTimestamp: parsed.args.creationTimestamp,
+          ipfsHash: parsed.args.ipfsHash,
+          tokenizationTime: parsed.args.tokenizationTime,
+          blockNumber: parsed.args.blockNumber
+          // fileName not in v2.11 event
+        };
+      }
+      async estimateGasForMint(contract, merkleRoot, encryptedHash, creationTimestamp, ipfsHash, metadataURI) {
+        const contractTyped = contract;
+        return await contractTyped.publicMintZipFile.estimateGas(merkleRoot, encryptedHash || "", creationTimestamp, ipfsHash, metadataURI);
+      }
+    };
+    exports2.V2_11Adapter = V2_11Adapter;
+  }
+});
+
+// node_modules/neozipkit/dist/blockchain/core/adapters/AdapterFactory.js
+var require_AdapterFactory = __commonJS({
+  "node_modules/neozipkit/dist/blockchain/core/adapters/AdapterFactory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getAdapter = getAdapter;
+    exports2.getAdapterByChainId = getAdapterByChainId;
+    var ContractVersionRegistry_1 = require_ContractVersionRegistry();
+    var V2_10Adapter_1 = require_V2_10Adapter();
+    var V2_11Adapter_1 = require_V2_11Adapter();
+    function getAdapter(version) {
+      const normalized = (0, ContractVersionRegistry_1.normalizeVersion)(version);
+      if (!normalized) {
+        throw new Error(`Invalid contract version: "${version}" (normalized to empty string)`);
+      }
+      if (!(0, ContractVersionRegistry_1.isVersionSupported)(normalized)) {
+        throw new Error(`Unsupported contract version: "${version}" (normalized: "${normalized}"). Supported versions: 2.10, 2.11`);
+      }
+      switch (normalized) {
+        case "2.10":
+          return new V2_10Adapter_1.V2_10Adapter();
+        case "2.11":
+          return new V2_11Adapter_1.V2_11Adapter();
+        default:
+          throw new Error(`Unsupported contract version: "${version}" (normalized: "${normalized}"). Supported versions: 2.10, 2.11`);
+      }
+    }
+    __name(getAdapter, "getAdapter");
+    function getAdapterByChainId(chainId, version) {
+      if (version) {
+        return getAdapter(version);
+      }
+      const { getContractConfig } = require_contracts();
+      const config = getContractConfig(chainId);
+      if (!config) {
+        throw new Error(`No contract config found for chainId: ${chainId}`);
+      }
+      if (!config.version) {
+        throw new Error(`Contract version not specified for chainId: ${chainId}`);
+      }
+      return getAdapter(config.version);
+    }
+    __name(getAdapterByChainId, "getAdapterByChainId");
+  }
+});
+
+// node_modules/neozipkit/dist/blockchain/core/contracts.js
 var require_contracts = __commonJS({
-  "neozipkit/dist/blockchain/core/contracts.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/core/contracts.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.isNetworkSupported = exports2.getSupportedNetworks = exports2.getContractConfig = exports2.CURRENT_DEPLOYMENT = exports2.DEFAULT_NETWORK = exports2.NZIP_CONTRACT_ABI_WEB3 = exports2.NZIP_CONTRACT_ABI = exports2.CONTRACT_CONFIGS = void 0;
@@ -75,13 +352,16 @@ var require_contracts = __commonJS({
     exports2.getChainIdByName = getChainIdByName;
     exports2.getNetworkByName = getNetworkByName;
     exports2.getSupportedNetworkNames = getSupportedNetworkNames;
+    exports2.getContractAdapter = getContractAdapter;
+    exports2.getContractAdapterByVersion = getContractAdapterByVersion;
     exports2.fuzzyMatchNetworkName = fuzzyMatchNetworkName;
     exports2.CONTRACT_CONFIGS = {
-      // Base Sepolia (Primary testnet) - DEFAULT
+      // Base Sepolia (Primary testnet)
       84532: {
         // address: '0xFD76a5d420704F34d84b0767961835c43D7b30a8', // Production contract v2.0
-        address: "0xdAe9D83d7AC62197fAE7704abc66b13DA28D3143",
-        // Production contract v2.10
+        // address: '0xdAe9D83d7AC62197fAE7704abc66b13DA28D3143', // Production contract v2.10
+        address: "0xc88F1a9C32bC024Bd082BAe023E10a3BCC5c0e3e",
+        // Production contract v2.11
         network: "Base Sepolia",
         chainId: 84532,
         explorerUrl: "https://sepolia.basescan.org",
@@ -90,6 +370,7 @@ var require_contracts = __commonJS({
           "https://base-sepolia-rpc.publicnode.com",
           "https://base-sepolia.gateway.tenderly.co"
         ],
+        version: "2.11",
         nameAliases: ["base-sepolia", "base sepolia", "basesepolia", "base-sepolia-testnet"]
       },
       // Base Mainnet (Production)
@@ -105,12 +386,37 @@ var require_contracts = __commonJS({
           "https://base.drpc.org",
           "https://base.gateway.tenderly.co"
         ],
+        version: "2.10",
         nameAliases: ["base-mainnet", "base mainnet", "basemainnet", "base"]
       },
+      // Ethereum Sepolia (Testnet)
+      // WARNING: Sepolia testnet has been experiencing instability since the Pectra upgrade (March 2025)
+      // Network issues include transaction processing failures and RPC timeouts
+      // Consider using Base Sepolia (84532) for more reliable testing
+      11155111: {
+        // address: '0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60', // Production contract v2.10
+        address: "0x007e8888D976b0b9B6073694Da32B7b6e393f890",
+        // Production contract v2.11
+        network: "Sepolia Testnet",
+        chainId: 11155111,
+        explorerUrl: "https://sepolia.etherscan.io",
+        rpcUrls: [
+          // Official Sepolia RPC endpoints (most reliable)
+          "https://rpc.sepolia.ethpandaops.io",
+          // Popular public RPC providers
+          "https://eth-sepolia.public.blastapi.io",
+          "https://ethereum-sepolia-rpc.publicnode.com",
+          "https://sepolia.drpc.org",
+          "https://1rpc.io/sepolia"
+        ],
+        version: "2.11",
+        nameAliases: ["sepolia-testnet", "sepolia testnet", "sepoliatestnet", "sepolia", "ethereum-sepolia", "ethereum sepolia"]
+      },
       // Arbitrum Sepolia (Testnet)
       421614: {
-        address: "0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60",
-        // Production contract v2.10
+        // address: '0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60', // Production contract v2.10
+        address: "0x3b99a72cCAc108037741cacb0D60d5571CF6412C",
+        // Production contract v2.11
         network: "Arbitrum Sepolia",
         chainId: 421614,
         explorerUrl: "https://sepolia.arbiscan.io",
@@ -118,6 +424,7 @@ var require_contracts = __commonJS({
           "https://sepolia-rollup.arbitrum.io/rpc",
           "https://arbitrum-sepolia-rpc.publicnode.com"
         ],
+        version: "2.11",
         nameAliases: ["arbitrum-sepolia", "arbitrum sepolia", "arbitrumsepolia", "arbitrum-sepolia-testnet"]
       },
       // Arbitrum One (Production)
@@ -134,28 +441,8 @@ var require_contracts = __commonJS({
           "https://arbitrum.llamarpc.com",
           "https://arbitrum.publicnode.com"
         ],
+        version: "2.10",
         nameAliases: ["arbitrum-one", "arbitrum one", "arbitrumone", "arbitrum", "arbitrum-mainnet", "arbitrum mainnet"]
-      },
-      // Ethereum Sepolia (Testnet)
-      // WARNING: Sepolia testnet has been experiencing instability since the Pectra upgrade (March 2025)
-      // Network issues include transaction processing failures and RPC timeouts
-      // Consider using Base Sepolia (84532) for more reliable testing
-      11155111: {
-        address: "0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60",
-        // Production contract v2.10
-        network: "Sepolia Testnet",
-        chainId: 11155111,
-        explorerUrl: "https://sepolia.etherscan.io",
-        rpcUrls: [
-          // Official Sepolia RPC endpoints (most reliable)
-          "https://rpc.sepolia.ethpandaops.io",
-          // Popular public RPC providers
-          "https://eth-sepolia.public.blastapi.io",
-          "https://ethereum-sepolia-rpc.publicnode.com",
-          "https://sepolia.drpc.org",
-          "https://1rpc.io/sepolia"
-        ],
-        nameAliases: ["sepolia-testnet", "sepolia testnet", "sepoliatestnet", "sepolia", "ethereum-sepolia", "ethereum sepolia"]
       }
       // Ethereum Mainnet (Production) - disabled until NZIP is deployed
       // 1: {
@@ -167,10 +454,15 @@ var require_contracts = __commonJS({
       // }
     };
     exports2.NZIP_CONTRACT_ABI = [
-      "function publicMintZipFile(string memory merkleRootHash, uint256 creationTimestamp, string memory ipfsHash, string memory metadataURI) public returns (uint256)",
+      // Minting function (v2.11 signature with encryptedHash for new mints)
+      "function publicMintZipFile(string memory merkleRootHash, string memory encryptedHash, uint256 creationTimestamp, string memory ipfsHash, string memory metadataURI) public returns (uint256)",
       "function totalSupply() external view returns (uint256)",
       "function getTokensByMerkleRoot(string memory merkleRoot) external view returns (uint256[])",
       "function getTokensByOwner(address owner) external view returns (uint256[])",
+      // Minimal getZipFileInfo - only declares fields we need (works for both v2.10 and v2.11)
+      // v2.10: returns (merkleRootHash, ipfsHash, creator, creationTimestamp, tokenizationTime, blockNumber)
+      // v2.11: returns (merkleRootHash, encryptedHash, ipfsHash, creator, creationTimestamp, tokenizationTime, blockNumber)
+      // By only declaring merkleRootHash and tokenizationTime, we can read both versions
       "function getZipFileInfo(uint256 tokenId) external view returns (tuple(string merkleRootHash, string ipfsHash, address creator, uint256 creationTimestamp, uint256 tokenizationTime, uint256 blockNumber))",
       "function ownerOf(uint256 tokenId) external view returns (address)",
       "function balanceOf(address owner) external view returns (uint256)",
@@ -178,12 +470,14 @@ var require_contracts = __commonJS({
       "function verifyZipFile(uint256 tokenId, string memory providedMerkleRoot) external view returns (bool isValid)",
       "function getVersion() external pure returns (string memory)",
       "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)",
-      "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
+      // v2.11 event with encryptedHash (v2.10 doesn't emit this event during minting, only v2.11 does)
+      "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string merkleRootHash, string encryptedHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
     ];
     exports2.NZIP_CONTRACT_ABI_WEB3 = [
       {
         inputs: [
           { name: "merkleRootHash", type: "string" },
+          { name: "encryptedHash", type: "string" },
           { name: "creationTimestamp", type: "uint256" },
           { name: "ipfsHash", type: "string" },
           { name: "metadataURI", type: "string" }
@@ -214,6 +508,7 @@ var require_contracts = __commonJS({
           {
             components: [
               { name: "merkleRootHash", type: "string" },
+              { name: "encryptedHash", type: "string" },
               { name: "ipfsHash", type: "string" },
               { name: "creator", type: "address" },
               { name: "creationTimestamp", type: "uint256" },
@@ -264,6 +559,16 @@ var require_contracts = __commonJS({
         stateMutability: "view",
         type: "function"
       },
+      {
+        inputs: [
+          { name: "tokenId", type: "uint256" },
+          { name: "providedEncryptedHash", type: "string" }
+        ],
+        name: "verifyEncryptedZipFile",
+        outputs: [{ name: "isValid", type: "bool" }],
+        stateMutability: "view",
+        type: "function"
+      },
       {
         inputs: [],
         name: "getVersion",
@@ -287,6 +592,7 @@ var require_contracts = __commonJS({
           { indexed: true, name: "tokenId", type: "uint256" },
           { indexed: true, name: "creator", type: "address" },
           { indexed: false, name: "merkleRootHash", type: "string" },
+          { indexed: false, name: "encryptedHash", type: "string" },
           { indexed: false, name: "creationTimestamp", type: "uint256" },
           { indexed: false, name: "ipfsHash", type: "string" },
           { indexed: false, name: "tokenizationTime", type: "uint256" },
@@ -351,6 +657,23 @@ var require_contracts = __commonJS({
       return names;
     }
     __name(getSupportedNetworkNames, "getSupportedNetworkNames");
+    function getContractAdapter(chainId) {
+      const config = (0, exports2.getContractConfig)(chainId);
+      if (!config) {
+        throw new Error(`No contract config found for chainId: ${chainId}`);
+      }
+      if (!config.version) {
+        throw new Error(`Contract version not specified for chainId: ${chainId}`);
+      }
+      const { getAdapter } = require_AdapterFactory();
+      return getAdapter(config.version);
+    }
+    __name(getContractAdapter, "getContractAdapter");
+    function getContractAdapterByVersion(version) {
+      const { getAdapter } = require_AdapterFactory();
+      return getAdapter(version);
+    }
+    __name(getContractAdapterByVersion, "getContractAdapterByVersion");
     function fuzzyMatchNetworkName(networkName) {
       const normalized = normalizeNetworkName(networkName);
       const exactMatch = getNetworkByName(networkName);
@@ -385,9 +708,9 @@ var require_contracts = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/core/ZipkitMinter.js
+// node_modules/neozipkit/dist/blockchain/core/ZipkitMinter.js
 var require_ZipkitMinter = __commonJS({
-  "neozipkit/dist/blockchain/core/ZipkitMinter.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/core/ZipkitMinter.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ZipkitMinter = void 0;
@@ -400,6 +723,7 @@ var require_ZipkitMinter = __commonJS({
       }
       constructor(merkleRoot, options) {
         this.merkleRoot = merkleRoot;
+        this.encryptedHash = options.encryptedHash || "";
         this.debug = options.debug || false;
         this.rpcUrlIndex = options.rpcUrlIndex ?? 0;
         const chainId = (0, contracts_1.getChainIdByName)(options.network);
@@ -441,7 +765,8 @@ var require_ZipkitMinter = __commonJS({
         return {
           address: this.wallet.address,
           balance: balanceInEth,
-          networkName: this.networkConfig.network
+          networkName: this.networkConfig.network,
+          chainId: this.networkConfig.chainId
         };
       }
       /**
@@ -532,8 +857,11 @@ var require_ZipkitMinter = __commonJS({
       async estimateGasCosts() {
         const creationTimestamp = Math.floor(Date.now() / 1e3);
         const metadata = this.createTokenMetadataString();
-        const gasLimit = await this.contract.publicMintZipFile.estimateGas(
+        const adapter = (0, contracts_1.getContractAdapter)(this.networkConfig.chainId);
+        const gasLimit = await adapter.estimateGasForMint(
+          this.contract,
           this.merkleRoot,
+          this.encryptedHash || void 0,
           creationTimestamp,
           "",
           // ipfsHash
@@ -568,16 +896,23 @@ var require_ZipkitMinter = __commonJS({
        */
       createTokenMetadata(tokenId, transactionHash, blockNumber) {
         const now = /* @__PURE__ */ new Date();
+        if (!this.networkConfig.version) {
+          throw new Error(`Contract version not specified for network ${this.networkConfig.network} (chainId: ${this.networkConfig.chainId})`);
+        }
         return {
           tokenId,
           network: this.networkConfig.network,
           networkChainId: this.networkConfig.chainId,
           contractAddress: this.networkConfig.address,
           merkleRoot: this.merkleRoot,
+          encryptedHash: this.encryptedHash || void 0,
+          // Include encrypted hash if present (v2.11+)
           mintDate: now.toLocaleDateString("en-US") + " at " + now.toLocaleTimeString("en-US"),
           creationTimestamp: Math.floor(now.getTime() / 1e3),
           transactionHash,
-          blockNumber
+          blockNumber,
+          contractVersion: this.networkConfig.version
+          // Required - always set from networkConfig
         };
       }
       /**
@@ -600,10 +935,13 @@ var require_ZipkitMinter = __commonJS({
           }
           let gasLimit;
           let gasPrice;
+          const adapter = (0, contracts_1.getContractAdapter)(this.networkConfig.chainId);
           try {
             const gasEstimate = await Promise.race([
-              this.contract.publicMintZipFile.estimateGas(
+              adapter.estimateGasForMint(
+                this.contract,
                 this.merkleRoot,
+                this.encryptedHash || void 0,
                 creationTimestamp,
                 "",
                 // ipfsHash
@@ -643,8 +981,10 @@ var require_ZipkitMinter = __commonJS({
             console.log(`[DEBUG] Submitting transaction with gas limit: ${gasLimit.toString()}, gas price: ${ethers_1.ethers.formatUnits(gasPrice, "gwei")} gwei`);
           }
           const tx = await Promise.race([
-            this.contract.publicMintZipFile(
+            adapter.mintZipFile(
+              this.contract,
               this.merkleRoot,
+              this.encryptedHash || void 0,
               creationTimestamp,
               "",
               // ipfsHash (empty since we store in ZIP)
@@ -696,17 +1036,17 @@ var require_ZipkitMinter = __commonJS({
           let actualTokenId = tokenId;
           if (receipt.logs && receipt.logs.length > 0) {
             try {
-              const iface = new ethers_1.ethers.Interface(contracts_1.NZIP_CONTRACT_ABI);
               for (const log of receipt.logs) {
                 try {
-                  const parsed = iface.parseLog(log);
-                  if (parsed?.name === "ZipFileTokenized") {
-                    actualTokenId = parsed.args.tokenId.toString();
-                    if (this.debug) {
-                      console.log(`[DEBUG] Actual token ID from contract event: ${actualTokenId}`);
-                    }
-                    break;
+                  const parsedEvent = adapter.parseZipFileTokenizedEvent({
+                    topics: log.topics,
+                    data: log.data
+                  });
+                  actualTokenId = parsedEvent.tokenId.toString();
+                  if (this.debug) {
+                    console.log(`[DEBUG] Actual token ID from contract event: ${actualTokenId}`);
                   }
+                  break;
                 } catch (e) {
                 }
               }
@@ -819,6 +1159,59 @@ var require_ZipkitMinter = __commonJS({
           }
         }
       }
+      /**
+       * Mint token with retry logic and exponential backoff
+       * @param maxRetries Maximum number of retry attempts (default: 3)
+       * @returns Minting result with retry information
+       */
+      async mintTokenWithRetry(maxRetries = 3) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+          try {
+            console.log(`\u{1F504} Minting attempt ${attempt}/${maxRetries}`);
+            const result = await this.mintToken();
+            if (result.success) {
+              console.log(`\u2705 Minting successful on attempt ${attempt}`);
+              return result;
+            }
+            lastError = new Error(result.message || "Minting failed");
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error("Unknown error");
+            console.warn(`\u274C Minting attempt ${attempt} failed:`, lastError.message);
+            if (attempt < maxRetries) {
+              const delay = Math.pow(2, attempt) * 1e3;
+              console.log(`\u23F3 Waiting ${delay}ms before retry...`);
+              await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+          }
+        }
+        return {
+          success: false,
+          message: `Minting failed after ${maxRetries} attempts: ${lastError?.message || "Unknown error"}`
+        };
+      }
+      /**
+       * Batch minting for multiple archives
+       * @param archives Array of archive objects with name and merkleRoot
+       * @returns Array of minting results
+       */
+      async mintBatch(archives) {
+        const results = [];
+        for (const archive of archives) {
+          try {
+            this.merkleRoot = archive.merkleRoot;
+            const result = await this.mintToken();
+            results.push(result);
+            await new Promise((resolve) => setTimeout(resolve, 1e3));
+          } catch (error) {
+            results.push({
+              success: false,
+              message: `Failed to mint ${archive.name}: ${error instanceof Error ? error.message : "Unknown error"}`
+            });
+          }
+        }
+        return results;
+      }
     };
     exports2.ZipkitMinter = ZipkitMinter;
     function validatePrivateKey(privateKey) {
@@ -833,24 +1226,160 @@ var require_ZipkitMinter = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/core/ZipkitVerifier.js
+// node_modules/neozipkit/dist/blockchain/core/ZipkitVerifier.js
 var require_ZipkitVerifier = __commonJS({
-  "neozipkit/dist/blockchain/core/ZipkitVerifier.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/core/ZipkitVerifier.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ZipkitVerifier = void 0;
     var ethers_1 = require("ethers");
     var contracts_1 = require_contracts();
-    var ZipkitVerifier = class {
+    var AdapterFactory_1 = require_AdapterFactory();
+    var ContractVersionRegistry_1 = require_ContractVersionRegistry();
+    var ZipkitVerifier = class _ZipkitVerifier {
       static {
         __name(this, "ZipkitVerifier");
       }
       constructor(options = {}) {
         this.debug = options.debug || false;
+        this.maxRetries = options.maxRetries || 3;
+        this.retryDelay = options.retryDelay || 1e3;
+        this.batchDelay = options.batchDelay || 500;
         if (this.debug) {
           console.log(`[DEBUG] ZipkitVerifier initialized`);
         }
       }
+      /**
+       * Extracts and normalizes token metadata from a tokenized ZIP archive.
+       *
+       * Handles field name variations across different token versions:
+       * - chainId vs networkChainId
+       * - timestamp vs mintedAt
+       * - Validates required fields
+       *
+       * @param zipkit - ZipkitNode instance with loaded archive
+       * @returns Normalized TokenMetadata or null if not tokenized
+       * @throws Error if TOKEN file exists but is invalid
+       *
+       * @example
+       * ```typescript
+       * import { ZipkitNode } from 'neozipkit/node';
+       * import { ZipkitVerifier } from 'neozipkit/blockchain';
+       *
+       * const zipkit = new ZipkitNode();
+       * await zipkit.loadZipFile('archive.nzip');
+       * const metadata = await ZipkitVerifier.extractTokenMetadata(zipkit);
+       * if (metadata) {
+       *   console.log(`Token ID: ${metadata.tokenId}`);
+       *   console.log(`Network: ${metadata.network}`);
+       * }
+       * ```
+       */
+      static async extractTokenMetadata(zipkit) {
+        try {
+          const tokenEntry = zipkit.getZipEntry("META-INF/NZIP.TOKEN");
+          if (!tokenEntry) {
+            return null;
+          }
+          const tokenDataBuffer = await zipkit.extractToBuffer(tokenEntry, {
+            skipHashCheck: false
+          });
+          const tokenData = tokenDataBuffer.toString("utf-8");
+          const rawMetadata = JSON.parse(tokenData);
+          const chainId = rawMetadata.chainId ?? rawMetadata.networkChainId;
+          const timestamp = rawMetadata.timestamp ?? rawMetadata.mintedAt;
+          let networkChainId = chainId;
+          let contractVersion = rawMetadata.contractVersion;
+          if (!networkChainId && rawMetadata.network) {
+            const networkConfig = (0, contracts_1.getNetworkByName)(rawMetadata.network);
+            if (networkConfig) {
+              networkChainId = networkConfig.chainId;
+              console.warn(`[WARNING] TOKEN file missing networkChainId - inferred ${networkChainId} from network name "${rawMetadata.network}"`);
+            }
+          }
+          if (!networkChainId) {
+            throw new Error('Invalid token metadata: missing required field "networkChainId" (and could not infer from network name)');
+          }
+          if (!contractVersion) {
+            console.warn(`[WARNING] TOKEN file missing contractVersion (common for v2.10 files) - verification will try all versions automatically`);
+            contractVersion = "unknown";
+          }
+          const metadata = {
+            tokenId: rawMetadata.tokenId,
+            contractAddress: rawMetadata.contractAddress,
+            network: rawMetadata.network,
+            networkChainId,
+            // Required - now guaranteed to be set
+            contractVersion,
+            // Required - now guaranteed to be set
+            merkleRoot: rawMetadata.merkleRoot,
+            creationTimestamp: rawMetadata.blockNumber || rawMetadata.creationTimestamp,
+            transactionHash: rawMetadata.transactionHash,
+            owner: rawMetadata.owner || rawMetadata.ownerAddress,
+            encryptedHash: rawMetadata.encryptedHash,
+            mintedAt: rawMetadata.mintedAt || rawMetadata.mintDate,
+            mintDate: rawMetadata.mintDate || rawMetadata.mintedAt,
+            ipfsHash: rawMetadata.ipfsHash,
+            blockNumber: rawMetadata.blockNumber
+          };
+          if (!metadata.tokenId || !metadata.contractAddress || !metadata.merkleRoot) {
+            throw new Error("Invalid token metadata: missing required fields (tokenId, contractAddress, or merkleRoot)");
+          }
+          return metadata;
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("Invalid token metadata")) {
+            throw error;
+          }
+          return null;
+        }
+      }
+      /**
+       * Instance method for convenience - extracts token metadata from loaded archive
+       * @param zipkit - ZipkitNode instance with loaded archive
+       * @returns Normalized TokenMetadata or null if not tokenized
+       */
+      async getTokenMetadata(zipkit) {
+        return _ZipkitVerifier.extractTokenMetadata(zipkit);
+      }
+      /**
+       * Query contract version from blockchain
+       * @param contractAddress - Contract address
+       * @param networkConfig - Network configuration with RPC URLs
+       * @param rpcUrlIndex - Optional RPC URL index (default: 0)
+       * @returns Contract version string or null if query fails
+       */
+      async queryContractVersion(contractAddress, networkConfig, rpcUrlIndex = 0) {
+        const rpcUrls = networkConfig.rpcUrls.length > 0 ? networkConfig.rpcUrls : [];
+        if (rpcUrls.length === 0 || rpcUrlIndex >= rpcUrls.length) {
+          return null;
+        }
+        const rpcUrl = rpcUrls[rpcUrlIndex];
+        let provider = null;
+        try {
+          provider = new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+          const contract = new ethers_1.ethers.Contract(contractAddress, contracts_1.NZIP_CONTRACT_ABI, provider);
+          const version = await Promise.race([
+            contract.getVersion(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("getVersion timeout after 10 seconds")), 1e4))
+          ]);
+          if (this.debug) {
+            console.log(`[DEBUG] Contract version queried from blockchain: ${version}`);
+          }
+          return version;
+        } catch (error) {
+          if (this.debug) {
+            console.log(`[DEBUG] Failed to query contract version: ${error.message || String(error)}`);
+          }
+          return null;
+        } finally {
+          try {
+            if (provider) {
+              provider.destroy();
+            }
+          } catch (cleanupError) {
+          }
+        }
+      }
       /**
        * Extract and validate token metadata from ZIP
        */
@@ -860,7 +1389,7 @@ var require_ZipkitVerifier = __commonJS({
             console.log(`[DEBUG] Extracting token metadata from buffer (${tokenBuffer.length} bytes)`);
           }
           const tokenData = JSON.parse(tokenBuffer.toString("utf8"));
-          const requiredFields = ["tokenId", "contractAddress", "network"];
+          const requiredFields = ["tokenId", "contractAddress", "network", "merkleRoot"];
           for (const field of requiredFields) {
             if (!tokenData[field]) {
               if (this.debug) {
@@ -872,16 +1401,85 @@ var require_ZipkitVerifier = __commonJS({
               };
             }
           }
-          if (this.debug) {
-            console.log(`[DEBUG] Token metadata extracted successfully`);
-            console.log(`[DEBUG] Token ID: ${tokenData.tokenId}, Network: ${tokenData.network}`);
+          let networkChainId = tokenData.networkChainId ?? tokenData.chainId;
+          let contractVersion = tokenData.contractVersion;
+          if (!networkChainId && tokenData.network) {
+            const networkConfig = (0, contracts_1.getNetworkByName)(tokenData.network);
+            if (networkConfig) {
+              networkChainId = networkConfig.chainId;
+              if (this.debug) {
+                console.log(`[DEBUG] TOKEN file missing networkChainId - inferred ${networkChainId} from network name "${tokenData.network}"`);
+              }
+            }
           }
-          return {
-            success: true,
-            metadata: tokenData
-          };
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : "Invalid JSON format";
+          if (!networkChainId) {
+            return {
+              success: false,
+              error: "Missing required field: networkChainId (and could not infer from network name)"
+            };
+          }
+          if (!contractVersion && networkChainId && tokenData.contractAddress) {
+            const networkConfig = (0, contracts_1.getContractConfig)(networkChainId);
+            if (networkConfig) {
+              if (this.debug) {
+                console.log(`[DEBUG] TOKEN file missing contractVersion - attempting to query from blockchain...`);
+              }
+              try {
+                const blockchainVersion = await this.queryContractVersion(tokenData.contractAddress, networkConfig, 0);
+                if (blockchainVersion) {
+                  const normalized = (0, ContractVersionRegistry_1.normalizeVersion)(blockchainVersion);
+                  if (normalized && (0, ContractVersionRegistry_1.isVersionSupported)(normalized)) {
+                    contractVersion = normalized;
+                    if (this.debug) {
+                      console.log(`[DEBUG] Successfully queried contractVersion from blockchain: ${contractVersion}`);
+                    }
+                  } else {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Queried version ${blockchainVersion} (normalized: ${normalized}) is not supported`);
+                    }
+                  }
+                }
+              } catch (queryError) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Failed to query contract version from blockchain: ${queryError.message || String(queryError)}`);
+                }
+              }
+            }
+          }
+          if (!contractVersion) {
+            if (this.debug) {
+              console.log(`[DEBUG] \u26A0\uFE0F  Contract version not found in TOKEN file or blockchain. Will try all versions during verification.`);
+            }
+            contractVersion = "unknown";
+          }
+          const metadata = {
+            tokenId: tokenData.tokenId,
+            contractAddress: tokenData.contractAddress,
+            network: tokenData.network,
+            networkChainId,
+            // Required - now guaranteed to be set
+            contractVersion,
+            // Required - now guaranteed to be set
+            merkleRoot: tokenData.merkleRoot,
+            transactionHash: tokenData.transactionHash,
+            blockNumber: tokenData.blockNumber,
+            owner: tokenData.owner || tokenData.ownerAddress,
+            encryptedHash: tokenData.encryptedHash,
+            mintedAt: tokenData.mintedAt || tokenData.mintDate,
+            mintDate: tokenData.mintDate || tokenData.mintedAt,
+            creationTimestamp: tokenData.creationTimestamp || tokenData.blockNumber,
+            ipfsHash: tokenData.ipfsHash
+          };
+          if (this.debug) {
+            console.log(`[DEBUG] Token metadata extracted successfully`);
+            console.log(`[DEBUG] Token ID: ${metadata.tokenId}, Network: ${metadata.network}, ChainId: ${metadata.networkChainId}, Version: ${metadata.contractVersion}`);
+          }
+          return {
+            success: true,
+            metadata
+          };
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Invalid JSON format";
           if (this.debug) {
             console.log(`[DEBUG] Failed to parse token metadata: ${errorMessage}`);
           }
@@ -1005,43 +1603,82 @@ var require_ZipkitVerifier = __commonJS({
           if (this.debug) {
             console.log(`[DEBUG] Calling contract.verifyZipFile(${tokenId}, ${merkleRoot.substring(0, 10)}...)`);
           }
+          const versionsToTry = [];
+          if (networkConfig.version && networkConfig.version !== "unknown") {
+            versionsToTry.push(networkConfig.version);
+          } else {
+            versionsToTry.push("2.10");
+          }
+          if (versionsToTry.length === 0) {
+            return {
+              success: false,
+              error: "No contract versions available to try. No versions implemented or detected."
+            };
+          }
           let onChainMerkleRoot;
           let onChainTokenizationTime;
           let onChainCreator;
           let onChainBlockNumber;
-          try {
-            const zipFileInfo = await Promise.race([
-              contract.getZipFileInfo(tokenId),
-              new Promise((_, reject) => setTimeout(() => reject(new Error("getZipFileInfo timeout after 10 seconds")), 1e4))
-            ]);
-            onChainMerkleRoot = zipFileInfo.merkleRootHash;
-            onChainTokenizationTime = Number(zipFileInfo.tokenizationTime);
-            onChainCreator = zipFileInfo.creator;
-            onChainBlockNumber = Number(zipFileInfo.blockNumber);
-            if (this.debug) {
-              console.log(`[DEBUG] Token ${tokenId} exists`);
-              console.log(`[DEBUG] On-chain merkle root: ${onChainMerkleRoot}`);
-              console.log(`[DEBUG] On-chain tokenization time: ${onChainTokenizationTime} (${new Date(onChainTokenizationTime * 1e3).toLocaleString()})`);
-              console.log(`[DEBUG] On-chain creator: ${onChainCreator}`);
-              console.log(`[DEBUG] On-chain block number: ${onChainBlockNumber}`);
-              console.log(`[DEBUG] Calculated merkle root: ${merkleRoot}`);
-            }
-          } catch (infoError) {
-            const errorMsg = infoError.message || String(infoError);
-            if (this.debug) {
-              console.log(`[DEBUG] Token info check failed: ${errorMsg}`);
-            }
-            if (errorMsg.includes("nonexistent token") || errorMsg.includes("ERC721: invalid token ID")) {
-              return {
-                success: false,
-                error: `Token ${tokenId} does not exist on contract ${contractAddress}`
-              };
+          let onChainEncryptedHash;
+          let lastError;
+          let successfulVersion;
+          for (const version of versionsToTry) {
+            try {
+              if (this.debug) {
+                console.log(`[DEBUG] Trying contract version: ${version}`);
+              }
+              const adapter = (0, AdapterFactory_1.getAdapter)(version);
+              const zipFileInfo = await Promise.race([
+                adapter.getZipFileInfo(contract, BigInt(tokenId)),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("getZipFileInfo timeout after 10 seconds")), 1e4))
+              ]);
+              onChainMerkleRoot = zipFileInfo.merkleRootHash;
+              onChainTokenizationTime = Number(zipFileInfo.tokenizationTime);
+              onChainCreator = zipFileInfo.creator;
+              onChainBlockNumber = Number(zipFileInfo.blockNumber);
+              onChainEncryptedHash = zipFileInfo.encryptedHash || void 0;
+              successfulVersion = version;
+              if (this.debug) {
+                console.log(`[DEBUG] Successfully queried token info using version ${version}`);
+                console.log(`[DEBUG] Token ${tokenId} exists`);
+                console.log(`[DEBUG] On-chain merkle root: ${onChainMerkleRoot}`);
+                console.log(`[DEBUG] On-chain tokenization time: ${onChainTokenizationTime} (${new Date(onChainTokenizationTime * 1e3).toLocaleString()})`);
+                console.log(`[DEBUG] On-chain creator: ${onChainCreator}`);
+                console.log(`[DEBUG] On-chain block number: ${onChainBlockNumber}`);
+                console.log(`[DEBUG] Calculated merkle root: ${merkleRoot}`);
+              }
+              break;
+            } catch (infoError) {
+              const errorMsg = infoError.message || String(infoError);
+              lastError = errorMsg;
+              if (this.debug) {
+                console.log(`[DEBUG] Version ${version} failed: ${errorMsg}`);
+              }
+              if (errorMsg.includes("nonexistent token") || errorMsg.includes("ERC721: invalid token ID")) {
+                return {
+                  success: false,
+                  error: `Token ${tokenId} does not exist on contract ${contractAddress}`
+                };
+              }
+              if (errorMsg.includes("out of result range") || errorMsg.includes("data out-of-bounds")) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Version ${version} incompatible (wrong return structure), trying next version...`);
+                }
+                continue;
+              }
+              continue;
             }
+          }
+          if (!onChainMerkleRoot) {
+            const triedVersions = versionsToTry.join(", ");
             return {
               success: false,
-              error: `Failed to get token info: ${errorMsg}`
+              error: `Failed to get token info after trying all versions (${triedVersions}). Last error: ${lastError || "Unknown error"}`
             };
           }
+          if (this.debug && successfulVersion && successfulVersion !== networkConfig.version) {
+            console.log(`[DEBUG] \u26A0\uFE0F  Contract version mismatch: network config says "${networkConfig.version || "unknown"}", but "${successfulVersion}" worked. Consider updating network config.`);
+          }
           const merkleRootMatch = onChainMerkleRoot && onChainMerkleRoot.toLowerCase() === merkleRoot.toLowerCase();
           if (this.debug) {
             console.log(`[DEBUG] Merkle root match: ${merkleRootMatch}`);
@@ -1126,7 +1763,14 @@ var require_ZipkitVerifier = __commonJS({
               }
             };
           }
-          const onChainResult = await this.verifyOnChain(tokenMetadata.tokenId, tokenMetadata.contractAddress, networkConfig, calculatedMerkleRoot, rpcUrlIndex);
+          const configToUse = { ...networkConfig };
+          if (!tokenMetadata.contractVersion || tokenMetadata.contractVersion === "unknown") {
+            if (this.debug) {
+              console.log(`[DEBUG] TOKEN file missing contractVersion - overriding network config version to default to v2.10`);
+            }
+            configToUse.version = "unknown";
+          }
+          const onChainResult = await this.verifyOnChain(tokenMetadata.tokenId, tokenMetadata.contractAddress, configToUse, calculatedMerkleRoot, rpcUrlIndex);
           if (!onChainResult.success) {
             return {
               success: false,
@@ -1215,14 +1859,203 @@ var require_ZipkitVerifier = __commonJS({
           };
         }
       }
+      /**
+       * Verify token with retry logic and exponential backoff
+       * @param tokenMetadata Token metadata to verify
+       * @param calculatedMerkleRoot Calculated merkle root from archive
+       * @param maxRetries Maximum number of retry attempts (default: uses instance maxRetries)
+       * @returns Enhanced verification result with retry information
+       */
+      async verifyTokenWithRetry(tokenMetadata, calculatedMerkleRoot, maxRetries) {
+        const startTime = Date.now();
+        const retries = maxRetries || this.maxRetries;
+        let lastError = null;
+        for (let attempt = 1; attempt <= retries; attempt++) {
+          try {
+            console.log(`\u{1F504} Verification attempt ${attempt}/${retries} for token ${tokenMetadata.tokenId}`);
+            const result = await this.verifyToken(tokenMetadata, calculatedMerkleRoot);
+            if (result.success) {
+              console.log(`\u2705 Verification successful on attempt ${attempt} for token ${tokenMetadata.tokenId}`);
+              return {
+                ...result,
+                retryAttempts: attempt,
+                processingTime: Date.now() - startTime,
+                timestamp: Date.now()
+              };
+            }
+            lastError = new Error(result.message || "Verification failed");
+          } catch (error) {
+            lastError = error instanceof Error ? error : new Error("Unknown verification error");
+            console.warn(`\u274C Verification attempt ${attempt} failed for token ${tokenMetadata.tokenId}:`, lastError.message);
+            if (attempt < retries) {
+              const delay = this.calculateRetryDelay(attempt);
+              console.log(`\u23F3 Waiting ${delay}ms before retry...`);
+              await this.delay(delay);
+            }
+          }
+        }
+        return {
+          success: false,
+          message: `Verification failed after ${retries} attempts: ${lastError?.message || "Unknown error"}`,
+          retryAttempts: retries,
+          processingTime: Date.now() - startTime,
+          timestamp: Date.now()
+        };
+      }
+      /**
+       * Batch verification for multiple tokens with rate limiting
+       * @param tokens Array of token metadata and merkle roots to verify
+       * @param options Batch processing options
+       * @returns Batch verification result
+       */
+      async verifyBatch(tokens, options = {}) {
+        const startTime = Date.now();
+        const { parallel = false, maxConcurrent = 3 } = options;
+        console.log(`\u{1F504} Starting batch verification for ${tokens.length} tokens (parallel: ${parallel})`);
+        let results = [];
+        if (parallel) {
+          results = await this.verifyBatchParallel(tokens, maxConcurrent);
+        } else {
+          results = await this.verifyBatchSequential(tokens);
+        }
+        const successfulVerifications = results.filter((r) => r.success).length;
+        const failedVerifications = results.length - successfulVerifications;
+        console.log(`\u2705 Batch verification completed: ${successfulVerifications}/${tokens.length} successful`);
+        return {
+          success: failedVerifications === 0,
+          totalTokens: tokens.length,
+          successfulVerifications,
+          failedVerifications,
+          results,
+          processingTime: Date.now() - startTime
+        };
+      }
+      /**
+       * Verify tokens in parallel with concurrency control
+       */
+      async verifyBatchParallel(tokens, maxConcurrent) {
+        const results = [];
+        const chunks = [];
+        for (let i = 0; i < tokens.length; i += maxConcurrent) {
+          chunks.push(tokens.slice(i, i + maxConcurrent));
+        }
+        for (const chunk of chunks) {
+          const chunkPromises = chunk.map((token) => this.verifyTokenWithRetry(token.tokenMetadata, token.calculatedMerkleRoot));
+          const chunkResults = await Promise.all(chunkPromises);
+          results.push(...chunkResults);
+          if (chunks.indexOf(chunk) < chunks.length - 1) {
+            await this.delay(this.batchDelay);
+          }
+        }
+        return results;
+      }
+      /**
+       * Verify tokens sequentially with rate limiting
+       */
+      async verifyBatchSequential(tokens) {
+        const results = [];
+        for (const token of tokens) {
+          const result = await this.verifyTokenWithRetry(token.tokenMetadata, token.calculatedMerkleRoot);
+          results.push(result);
+          if (tokens.indexOf(token) < tokens.length - 1) {
+            await this.delay(this.batchDelay);
+          }
+        }
+        return results;
+      }
+      /**
+       * Process verification jobs with priority queue
+       * @param jobs Array of verification jobs
+       * @param options Processing options
+       * @returns Batch verification result
+       */
+      async processVerificationJobs(jobs, options = {}) {
+        const { maxConcurrent = 3, priorityOrder = true, getTokenMetadata, getCalculatedMerkleRoot } = options;
+        if (!getTokenMetadata || !getCalculatedMerkleRoot) {
+          return {
+            success: false,
+            totalTokens: jobs.length,
+            successfulVerifications: 0,
+            failedVerifications: jobs.length,
+            results: [],
+            processingTime: 0
+          };
+        }
+        const sortedJobs = priorityOrder ? this.sortJobsByPriority(jobs) : jobs;
+        const tokens = [];
+        for (const job of sortedJobs) {
+          const tokenMetadata = await getTokenMetadata(job.tokenId);
+          const calculatedMerkleRoot = await getCalculatedMerkleRoot(job.tokenId);
+          if (tokenMetadata) {
+            tokens.push({
+              tokenMetadata,
+              calculatedMerkleRoot: calculatedMerkleRoot || null
+            });
+          }
+        }
+        return this.verifyBatch(tokens, { parallel: true, maxConcurrent });
+      }
+      /**
+       * Sort verification jobs by priority
+       */
+      sortJobsByPriority(jobs) {
+        const priorityOrder = { high: 0, normal: 1, low: 2 };
+        return jobs.sort((a, b) => {
+          const aPriority = priorityOrder[a.priority || "normal"];
+          const bPriority = priorityOrder[b.priority || "normal"];
+          if (aPriority !== bPriority) {
+            return aPriority - bPriority;
+          }
+          return (a.retryCount || 0) - (b.retryCount || 0);
+        });
+      }
+      /**
+       * Calculate retry delay with exponential backoff
+       */
+      calculateRetryDelay(attempt) {
+        return Math.min(this.retryDelay * Math.pow(2, attempt - 1), 3e4);
+      }
+      /**
+       * Utility method for delays
+       */
+      async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+      /**
+       * Get verification statistics
+       */
+      getVerificationStats() {
+        return {
+          maxRetries: this.maxRetries,
+          retryDelay: this.retryDelay,
+          batchDelay: this.batchDelay
+        };
+      }
+      /**
+       * Update verification configuration
+       */
+      updateConfig(config) {
+        if (config.maxRetries !== void 0) {
+          this.maxRetries = config.maxRetries;
+        }
+        if (config.retryDelay !== void 0) {
+          this.retryDelay = config.retryDelay;
+        }
+        if (config.batchDelay !== void 0) {
+          this.batchDelay = config.batchDelay;
+        }
+        if (this.debug) {
+          console.log("\u{1F527} ZipkitVerifier configuration updated:", this.getVerificationStats());
+        }
+      }
     };
     exports2.ZipkitVerifier = ZipkitVerifier;
   }
 });
 
-// neozipkit/dist/core/components/Logger.js
+// node_modules/neozipkit/dist/core/components/Logger.js
 var require_Logger = __commonJS({
-  "neozipkit/dist/core/components/Logger.js"(exports2) {
+  "node_modules/neozipkit/dist/core/components/Logger.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Logger = void 0;
@@ -1368,9 +2201,9 @@ var require_Logger = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/core/WalletManager.js
+// node_modules/neozipkit/dist/blockchain/core/WalletManager.js
 var require_WalletManager = __commonJS({
-  "neozipkit/dist/blockchain/core/WalletManager.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/core/WalletManager.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.WalletAnalyzer = exports2.CoreWalletManager = void 0;
@@ -1408,6 +2241,13 @@ var require_WalletManager = __commonJS({
       }
       /**
        * Setup wallet with private key and connect to network
+       *
+       * SECURITY WARNING: This method accepts a private key as a parameter.
+       * - Never hardcode private keys in source code
+       * - Always use environment variables for private keys
+       * - Use testnet keys for development/testing
+       * - Use secure key management (HSMs, KMS) for production
+       * - See SECURITY.md for complete security guidelines
        */
       async setupWallet(privateKey, network, mintToken = false) {
         try {
@@ -1725,12 +2565,12 @@ var require_WalletManager = __commonJS({
   }
 });
 
-// neozipkit/node_modules/moment/moment.js
+// node_modules/moment/moment.js
 var require_moment = __commonJS({
-  "neozipkit/node_modules/moment/moment.js"(exports2, module2) {
+  "node_modules/moment/moment.js"(exports2, module2) {
     (function(global, factory) {
       typeof exports2 === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : global.moment = factory();
-    })(exports2, function() {
+    })(exports2, (function() {
       "use strict";
       var hookCallback;
       function hooks() {
@@ -2485,8 +3325,13 @@ var require_moment = __commonJS({
             return void (isUTC ? d.setUTCHours(value) : d.setHours(value));
           case "Date":
             return void (isUTC ? d.setUTCDate(value) : d.setDate(value));
+          // case 'Day': // Not real
+          //    return void (isUTC ? d.setUTCDay(value) : d.setDay(value));
+          // case 'Month': // Not used because we need to pass two variables
+          //     return void (isUTC ? d.setUTCMonth(value) : d.setMonth(value));
           case "FullYear":
             break;
+          // See below ...
           default:
             return;
         }
@@ -4639,18 +5484,23 @@ var require_moment = __commonJS({
           case "second":
             output = (this - that) / 1e3;
             break;
+          // 1000
           case "minute":
             output = (this - that) / 6e4;
             break;
+          // 1000 * 60
           case "hour":
             output = (this - that) / 36e5;
             break;
+          // 1000 * 60 * 60
           case "day":
             output = (this - that - zoneDelta) / 864e5;
             break;
+          // 1000 * 60 * 60 * 24, negate dst
           case "week":
             output = (this - that - zoneDelta) / 6048e5;
             break;
+          // 1000 * 60 * 60 * 24 * 7, negate dst
           default:
             output = this - that;
         }
@@ -5421,7 +6271,7 @@ var require_moment = __commonJS({
       proto.toISOString = toISOString;
       proto.inspect = inspect;
       if (typeof Symbol !== "undefined" && Symbol.for != null) {
-        proto[Symbol.for("nodejs.util.inspect.custom")] = function() {
+        proto[/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")] = function() {
           return "Moment<" + this.format() + ">";
         };
       }
@@ -5621,10 +6471,10 @@ var require_moment = __commonJS({
           }
         ],
         dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
-        ordinal: function(number) {
+        ordinal: /* @__PURE__ */ __name(function(number) {
           var b = number % 10, output = toInt(number % 100 / 10) === 1 ? "th" : b === 1 ? "st" : b === 2 ? "nd" : b === 3 ? "rd" : "th";
           return number + output;
-        }
+        }, "ordinal")
       });
       hooks.lang = deprecate(
         "moment.lang is deprecated. Use moment.locale instead.",
@@ -5737,6 +6587,7 @@ var require_moment = __commonJS({
               return days2 * 1440 + milliseconds2 / 6e4;
             case "second":
               return days2 * 86400 + milliseconds2 / 1e3;
+            // Math.floor prevents floating point math errors here
             case "millisecond":
               return Math.floor(days2 * 864e5) + milliseconds2;
             default:
@@ -5980,13 +6831,13 @@ var require_moment = __commonJS({
         // <input type="month" />
       };
       return hooks;
-    });
+    }));
   }
 });
 
-// neozipkit/node_modules/moment-timezone/moment-timezone.js
+// node_modules/moment-timezone/moment-timezone.js
 var require_moment_timezone = __commonJS({
-  "neozipkit/node_modules/moment-timezone/moment-timezone.js"(exports2, module2) {
+  "node_modules/moment-timezone/moment-timezone.js"(exports2, module2) {
     (function(root, factory) {
       "use strict";
       if (typeof module2 === "object" && module2.exports) {
@@ -6102,27 +6953,27 @@ var require_moment_timezone = __commonJS({
       }
       __name(closest, "closest");
       Zone.prototype = {
-        _set: function(unpacked) {
+        _set: /* @__PURE__ */ __name(function(unpacked) {
           this.name = unpacked.name;
           this.abbrs = unpacked.abbrs;
           this.untils = unpacked.untils;
           this.offsets = unpacked.offsets;
           this.population = unpacked.population;
-        },
-        _index: function(timestamp) {
+        }, "_set"),
+        _index: /* @__PURE__ */ __name(function(timestamp) {
           var target = +timestamp, untils = this.untils, i;
           i = closest(target, untils);
           if (i >= 0) {
             return i;
           }
-        },
-        countries: function() {
+        }, "_index"),
+        countries: /* @__PURE__ */ __name(function() {
           var zone_name = this.name;
           return Object.keys(countries).filter(function(country_code) {
             return countries[country_code].zones.indexOf(zone_name) !== -1;
           });
-        },
-        parse: function(timestamp) {
+        }, "countries"),
+        parse: /* @__PURE__ */ __name(function(timestamp) {
           var target = +timestamp, offsets = this.offsets, untils = this.untils, max = untils.length - 1, offset, offsetNext, offsetPrev, i;
           for (i = 0; i < max; i++) {
             offset = offsets[i];
@@ -6138,17 +6989,17 @@ var require_moment_timezone = __commonJS({
             }
           }
           return offsets[max];
-        },
-        abbr: function(mom) {
+        }, "parse"),
+        abbr: /* @__PURE__ */ __name(function(mom) {
           return this.abbrs[this._index(mom)];
-        },
-        offset: function(mom) {
+        }, "abbr"),
+        offset: /* @__PURE__ */ __name(function(mom) {
           logError("zone.offset has been deprecated in favor of zone.utcOffset");
           return this.offsets[this._index(mom)];
-        },
-        utcOffset: function(mom) {
+        }, "offset"),
+        utcOffset: /* @__PURE__ */ __name(function(mom) {
           return this.offsets[this._index(mom)];
-        }
+        }, "utcOffset")
       };
       function Country(country_name, zone_names) {
         this.name = country_name;
@@ -6367,8 +7218,7 @@ var require_moment_timezone = __commonJS({
       __name(addLink, "addLink");
       function addCountries(data) {
         var i, country_code, country_zones, split;
-        if (!data || !data.length)
-          return;
+        if (!data || !data.length) return;
         for (i = 0; i < data.length; i++) {
           split = data[i].split("|");
           country_code = split[0].toUpperCase();
@@ -6387,8 +7237,7 @@ var require_moment_timezone = __commonJS({
       __name(getCountry, "getCountry");
       function zonesForCountry(country, with_offset) {
         country = getCountry(country);
-        if (!country)
-          return null;
+        if (!country) return null;
         var zones2 = country.zones.sort();
         if (with_offset) {
           return zones2.map(function(zone_name) {
@@ -6519,8 +7368,7 @@ var require_moment_timezone = __commonJS({
       __name(resetZoneWrap, "resetZoneWrap");
       function resetZoneWrap2(old) {
         return function() {
-          if (arguments.length > 0)
-            this._z = null;
+          if (arguments.length > 0) this._z = null;
           return old.apply(this, arguments);
         };
       }
@@ -6549,9 +7397,9 @@ var require_moment_timezone = __commonJS({
   }
 });
 
-// neozipkit/node_modules/moment-timezone/data/packed/latest.json
+// node_modules/moment-timezone/data/packed/latest.json
 var require_latest = __commonJS({
-  "neozipkit/node_modules/moment-timezone/data/packed/latest.json"(exports2, module2) {
+  "node_modules/moment-timezone/data/packed/latest.json"(exports2, module2) {
     module2.exports = {
       version: "2025b",
       zones: [
@@ -7408,17 +8256,17 @@ var require_latest = __commonJS({
   }
 });
 
-// neozipkit/node_modules/moment-timezone/index.js
+// node_modules/moment-timezone/index.js
 var require_moment_timezone2 = __commonJS({
-  "neozipkit/node_modules/moment-timezone/index.js"(exports2, module2) {
+  "node_modules/moment-timezone/index.js"(exports2, module2) {
     var moment = module2.exports = require_moment_timezone();
     moment.tz.load(require_latest());
   }
 });
 
-// neozipkit/dist/core/constants/Errors.js
+// node_modules/neozipkit/dist/core/constants/Errors.js
 var require_Errors = __commonJS({
-  "neozipkit/dist/core/constants/Errors.js"(exports2) {
+  "node_modules/neozipkit/dist/core/constants/Errors.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.default = {
@@ -7483,9 +8331,9 @@ var require_Errors = __commonJS({
   }
 });
 
-// neozipkit/dist/core/constants/Headers.js
+// node_modules/neozipkit/dist/core/constants/Headers.js
 var require_Headers = __commonJS({
-  "neozipkit/dist/core/constants/Headers.js"(exports2) {
+  "node_modules/neozipkit/dist/core/constants/Headers.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DOS_FILE_ATTR = exports2.FILE_SYSTEM = exports2.HDR_ID = exports2.EXTENSIBLE_DATA_FIELDS = exports2.GP_FLAG = exports2.CMP_METHOD = exports2.ZIP64_CENTRAL_END = exports2.ZIP64_CENTRAL_DIR = exports2.CENTRAL_END = exports2.CENTRAL_DIR = exports2.DATA_DESC = exports2.ENCRYPT_HDR_SIZE = exports2.LOCAL_HDR = exports2.TOKENIZED_METADATA = exports2.TIMESTAMP_METADATA = exports2.TIMESTAMP_SUBMITTED = exports2.DATA_DESCRIPTOR = exports2.ZIP64_CENTRAL_DIRECTORY_END = exports2.ZIP64_CENTRAL_DIRECTORY_LOCATOR = exports2.CENTRAL_DIRECTORY_END = exports2.CENTRAL_FILE_HEADER = exports2.LOCAL_FILE_HEADER = void 0;
@@ -7792,9 +8640,9 @@ var require_Headers = __commonJS({
   }
 });
 
-// neozipkit/dist/core/encryption/types.js
+// node_modules/neozipkit/dist/core/encryption/types.js
 var require_types2 = __commonJS({
-  "neozipkit/dist/core/encryption/types.js"(exports2) {
+  "node_modules/neozipkit/dist/core/encryption/types.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.EncryptionMethod = void 0;
@@ -7806,9 +8654,9 @@ var require_types2 = __commonJS({
   }
 });
 
-// neozipkit/dist/core/encryption/ZipCrypto.js
+// node_modules/neozipkit/dist/core/encryption/ZipCrypto.js
 var require_ZipCrypto = __commonJS({
-  "neozipkit/dist/core/encryption/ZipCrypto.js"(exports2) {
+  "node_modules/neozipkit/dist/core/encryption/ZipCrypto.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DecryptionStream = exports2.ZipCrypto = void 0;
@@ -8475,9 +9323,9 @@ var require_ZipCrypto = __commonJS({
   }
 });
 
-// neozipkit/dist/core/ZipEntry.js
+// node_modules/neozipkit/dist/core/ZipEntry.js
 var require_ZipEntry = __commonJS({
-  "neozipkit/dist/core/ZipEntry.js"(exports2) {
+  "node_modules/neozipkit/dist/core/ZipEntry.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -8545,8 +9393,10 @@ var require_ZipEntry = __commonJS({
           switch (this.platform) {
             case "darwin":
               return Headers_1.FILE_SYSTEM.DARWIN << 8 | VER_ENCODING;
+            // macOS/Darwin
             case "win32":
               return Headers_1.FILE_SYSTEM.NTFS << 8 | VER_ENCODING;
+            // Windows
             default:
               return Headers_1.FILE_SYSTEM.UNIX << 8 | VER_ENCODING;
           }
@@ -8961,10 +9811,13 @@ var require_ZipEntry = __commonJS({
             switch (this.bitFlags & 6) {
               case 0:
                 return "Deflate-N";
+              // Deflate Normal
               case 2:
                 return "Deflate-M";
+              // Deflate Maximum
               case 4:
                 return "Deflate-F";
+              // Deflate Fast
               case 6:
                 return "Deflate-S";
             }
@@ -9195,63 +10048,167 @@ var require_ZipEntry = __commonJS({
   }
 });
 
-// neozipkit/dist/core/components/HashCalculator.js
-var require_HashCalculator = __commonJS({
-  "neozipkit/dist/core/components/HashCalculator.js"(exports2) {
+// node_modules/neozipkit/dist/core/ZstdManager.js
+var require_ZstdManager = __commonJS({
+  "node_modules/neozipkit/dist/core/ZstdManager.js"(exports2) {
     "use strict";
-    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0)
-        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 === void 0)
-        k2 = k;
-      o[k2] = m[k];
-    });
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    } : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
-      var ownKeys = /* @__PURE__ */ __name(function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2)
-            if (Object.prototype.hasOwnProperty.call(o2, k))
-              ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      }, "ownKeys");
-      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")
-              __createBinding2(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    }();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.HashCalculator = void 0;
-    var crypto = __importStar(require("crypto"));
-    var ZipCrypto_1 = require_ZipCrypto();
-    var HashCalculator = class _HashCalculator {
+    exports2.ZstdManager = void 0;
+    var zstd_js_1 = require("@oneidentity/zstd-js");
+    var ZstdCodecManager = class _ZstdCodecManager {
       static {
-        __name(this, "HashCalculator");
+        __name(this, "ZstdCodecManager");
       }
-      /**
+      constructor() {
+        this.codec = null;
+        this.initPromise = null;
+        this.operationQueue = Promise.resolve();
+      }
+      /**
+       * Get the singleton instance of ZstdCodecManager
+       */
+      static getInstance() {
+        if (!_ZstdCodecManager.instance) {
+          _ZstdCodecManager.instance = new _ZstdCodecManager();
+        }
+        return _ZstdCodecManager.instance;
+      }
+      /**
+       * Ensure the Zstd codec is initialized
+       * This is called automatically before any compress/decompress operation
+       */
+      async ensureInitialized() {
+        if (this.codec) {
+          return;
+        }
+        if (this.initPromise) {
+          return this.initPromise;
+        }
+        this.initPromise = (async () => {
+          this.codec = await (0, zstd_js_1.ZstdInit)();
+        })();
+        return this.initPromise;
+      }
+      /**
+       * Queue an operation to ensure sequential execution
+       * This prevents concurrent operations from interfering with each other
+       */
+      async queueOperation(operation) {
+        const promise = this.operationQueue.then(operation, operation);
+        this.operationQueue = promise.catch(() => {
+        });
+        return promise;
+      }
+      /**
+       * Compress data using Zstd
+       * @param data - Data to compress (Uint8Array)
+       * @param level - Compression level (1-22, default 6)
+       * @returns Compressed data as Uint8Array
+       */
+      async compress(data, level = 6) {
+        return this.queueOperation(async () => {
+          await this.ensureInitialized();
+          if (!this.codec) {
+            throw new Error("Zstd codec not initialized");
+          }
+          return this.codec.ZstdSimple.compress(data, level);
+        });
+      }
+      /**
+       * Decompress data using Zstd
+       * @param data - Compressed data (Uint8Array or Buffer)
+       * @returns Decompressed data as Uint8Array
+       */
+      async decompress(data) {
+        return this.queueOperation(async () => {
+          await this.ensureInitialized();
+          if (!this.codec) {
+            throw new Error("Zstd codec not initialized");
+          }
+          const inputData = data instanceof Buffer ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data;
+          return this.codec.ZstdSimple.decompress(inputData);
+        });
+      }
+      /**
+       * Reset the manager (for testing purposes)
+       * @internal
+       */
+      static reset() {
+        _ZstdCodecManager.instance = null;
+      }
+    };
+    ZstdCodecManager.instance = null;
+    exports2.ZstdManager = {
+      /**
+       * Compress data using Zstd
+       * Operations are automatically queued to prevent interference
+       */
+      compress: /* @__PURE__ */ __name((data, level) => ZstdCodecManager.getInstance().compress(data, level), "compress"),
+      /**
+       * Decompress data using Zstd
+       * Operations are automatically queued to prevent interference
+       */
+      decompress: /* @__PURE__ */ __name((data) => ZstdCodecManager.getInstance().decompress(data), "decompress"),
+      /**
+       * Reset the manager (for testing)
+       * @internal
+       */
+      reset: /* @__PURE__ */ __name(() => ZstdCodecManager.reset(), "reset")
+    };
+    exports2.default = exports2.ZstdManager;
+  }
+});
+
+// node_modules/neozipkit/dist/core/components/HashCalculator.js
+var require_HashCalculator = __commonJS({
+  "node_modules/neozipkit/dist/core/components/HashCalculator.js"(exports2) {
+    "use strict";
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
+          return m[k];
+        }, "get") };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = /* @__PURE__ */ __name(function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      }, "ownKeys");
+      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") __createBinding2(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HashCalculator = void 0;
+    var crypto = __importStar(require("crypto"));
+    var ZipCrypto_1 = require_ZipCrypto();
+    var HashCalculator = class _HashCalculator {
+      static {
+        __name(this, "HashCalculator");
+      }
+      /**
        * Creates a new HashCalculator instance
        * @param options - Configuration options:
        *   - useSHA256: Enable SHA-256 calculation for incremental mode (default: false)
@@ -9523,26 +10480,18 @@ var require_HashCalculator = __commonJS({
   }
 });
 
-// neozipkit/dist/core/ZipCompress.js
+// node_modules/neozipkit/dist/core/ZipCompress.js
 var require_ZipCompress = __commonJS({
-  "neozipkit/dist/core/ZipCompress.js"(exports2) {
+  "node_modules/neozipkit/dist/core/ZipCompress.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ZipCompress = void 0;
     var pako = require("pako");
-    var zstd_js_1 = require("@oneidentity/zstd-js");
+    var ZstdManager_1 = require_ZstdManager();
     var Logger_1 = require_Logger();
     var Headers_1 = require_Headers();
     var HashCalculator_1 = require_HashCalculator();
     var ZipCrypto_1 = require_ZipCrypto();
-    var zstdCodec = null;
-    async function initZstd() {
-      if (!zstdCodec) {
-        zstdCodec = await (0, zstd_js_1.ZstdInit)();
-      }
-      return zstdCodec;
-    }
-    __name(initZstd, "initZstd");
     var ZipCompress = class _ZipCompress {
       static {
         __name(this, "ZipCompress");
@@ -9714,20 +10663,11 @@ var require_ZipCompress = __commonJS({
         if (typeof input === "object" && "totalSize" in input && "readChunk" in input) {
           throw new Error("Chunked reader mode not supported in ZipCompress");
         }
-        const zstdCodec2 = await initZstd();
         if (!input || input.length === 0) {
           throw new Error("ZSTD compression: empty input buffer");
         }
         const inputArray = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-        if (input.length <= effectiveBufferSize) {
-          const compressed2 = zstdCodec2.ZstdSimple.compress(inputArray, level);
-          const compressedBuffer2 = Buffer.from(compressed2);
-          if (onOutputBuffer) {
-            await onOutputBuffer(compressedBuffer2);
-          }
-          return compressedBuffer2;
-        }
-        const compressed = zstdCodec2.ZstdSimple.compress(inputArray, level);
+        const compressed = await ZstdManager_1.ZstdManager.compress(inputArray, level);
         const compressedBuffer = Buffer.from(compressed);
         if (onOutputBuffer) {
           await onOutputBuffer(compressedBuffer);
@@ -9782,28 +10722,20 @@ var require_ZipCompress = __commonJS({
   }
 });
 
-// neozipkit/dist/core/ZipDecompress.js
+// node_modules/neozipkit/dist/core/ZipDecompress.js
 var require_ZipDecompress = __commonJS({
-  "neozipkit/dist/core/ZipDecompress.js"(exports2) {
+  "node_modules/neozipkit/dist/core/ZipDecompress.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     var pako = require("pako");
-    var zstd_js_1 = require("@oneidentity/zstd-js");
+    var ZstdManager_1 = require_ZstdManager();
     var Logger_1 = require_Logger();
     var Errors_1 = __importDefault(require_Errors());
     var Headers_1 = require_Headers();
     var ZipCrypto_1 = require_ZipCrypto();
-    var zstdCodec = null;
-    async function initZstd() {
-      if (!zstdCodec) {
-        zstdCodec = await (0, zstd_js_1.ZstdInit)();
-      }
-      return zstdCodec;
-    }
-    __name(initZstd, "initZstd");
     var ZipDecompress = class _ZipDecompress {
       static {
         __name(this, "ZipDecompress");
@@ -9817,7 +10749,6 @@ var require_ZipDecompress = __commonJS({
         }
       }
       constructor(zipkit) {
-        this.zstdCodec = null;
         this.zipkit = zipkit;
         this.debug = false;
         if (_ZipDecompress.loggingEnabled) {
@@ -9835,12 +10766,9 @@ var require_ZipDecompress = __commonJS({
        */
       async extract(entry, skipHashCheck) {
         if (!this.zipkit.hasInBuffer()) {
-          throw new Error("extract() requires Buffer-based ZIP. Use ZipkitServer.extractToFile() for file-based ZIP or call loadZip() first.");
+          throw new Error("extract() requires Buffer-based ZIP. Use ZipkitNode.extractToFile() for file-based ZIP or call loadZip() first.");
         }
         this.log(`extract() called for entry: ${entry.filename}, method: ${entry.cmpMethod}, skipHashCheck: ${skipHashCheck}`);
-        if (entry.cmpMethod === Headers_1.CMP_METHOD.ZSTD && !this.zstdCodec) {
-          this.zstdCodec = await initZstd();
-        }
         const buffer = this.zipkit.ensureBuffer();
         let fdata = this.zipkit.parseLocalHeader(entry, buffer);
         if (entry.isEncrypted && this.zipkit?.password) {
@@ -9867,18 +10795,15 @@ var require_ZipDecompress = __commonJS({
        * ZSTD codec is guaranteed to be initialized via factory method
        * Internal method only
        */
-      zstdDecompressSync(data) {
+      async zstdDecompressSync(data) {
         this.log(`zstdDecompressSync() called with ${data.length} bytes`);
         try {
-          if (!this.zstdCodec) {
-            throw new Error("ZSTD codec not initialized.");
-          }
-          const decompressed = this.zstdCodec.ZstdSimple.decompress(data);
-          this.log(`ZSTD synchronous decompression successful: ${data.length} bytes -> ${decompressed.length} bytes`);
+          const decompressed = await ZstdManager_1.ZstdManager.decompress(data);
+          this.log(`ZSTD decompression successful: ${data.length} bytes -> ${decompressed.length} bytes`);
           return Buffer.from(decompressed);
         } catch (error) {
-          this.log(`ZSTD synchronous decompression failed: ${error}`);
-          throw new Error(`ZSTD synchronous decompression failed: ${error instanceof Error ? error.message : String(error)}`);
+          this.log(`ZSTD decompression failed: ${error}`);
+          throw new Error(`ZSTD decompression failed: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
       /**
@@ -9886,7 +10811,7 @@ var require_ZipDecompress = __commonJS({
        * Handles decompression and hash verification
        * Internal method only
        */
-      unCompress(compressedData, entry, skipHashCheck) {
+      async unCompress(compressedData, entry, skipHashCheck) {
         this.log(`unCompress() called for entry: ${entry.filename}, method: ${entry.cmpMethod}, data length: ${compressedData.length}`);
         if (compressedData.length === 0) {
           return Buffer.alloc(0);
@@ -9897,7 +10822,7 @@ var require_ZipDecompress = __commonJS({
         } else if (entry.cmpMethod === Headers_1.CMP_METHOD.DEFLATED) {
           outBuf = this.inflate(compressedData);
         } else if (entry.cmpMethod === Headers_1.CMP_METHOD.ZSTD) {
-          outBuf = this.zstdDecompressSync(compressedData);
+          outBuf = await this.zstdDecompressSync(compressedData);
         } else {
           throw new Error(`Unsupported compression method: ${entry.cmpMethod}`);
         }
@@ -9922,9 +10847,9 @@ var require_ZipDecompress = __commonJS({
   }
 });
 
-// neozipkit/dist/core/Zipkit.js
+// node_modules/neozipkit/dist/core/Zipkit.js
 var require_Zipkit = __commonJS({
-  "neozipkit/dist/core/Zipkit.js"(exports2) {
+  "node_modules/neozipkit/dist/core/Zipkit.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -9942,51 +10867,51 @@ var require_Zipkit = __commonJS({
     var ZipCrypto_1 = require_ZipCrypto();
     var HashCalculator_1 = __importDefault(require_HashCalculator());
     var Headers_1 = require_Headers();
-    Object.defineProperty(exports2, "LOCAL_HDR", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "LOCAL_HDR", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.LOCAL_HDR;
-    } });
-    Object.defineProperty(exports2, "ENCRYPT_HDR_SIZE", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "ENCRYPT_HDR_SIZE", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.ENCRYPT_HDR_SIZE;
-    } });
-    Object.defineProperty(exports2, "CMP_METHOD", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CMP_METHOD", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.CMP_METHOD;
-    } });
-    Object.defineProperty(exports2, "CENTRAL_END", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CENTRAL_END", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.CENTRAL_END;
-    } });
-    Object.defineProperty(exports2, "CENTRAL_DIR", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CENTRAL_DIR", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.CENTRAL_DIR;
-    } });
-    Object.defineProperty(exports2, "ZIP64_CENTRAL_END", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "ZIP64_CENTRAL_END", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.ZIP64_CENTRAL_END;
-    } });
-    Object.defineProperty(exports2, "ZIP64_CENTRAL_DIR", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "ZIP64_CENTRAL_DIR", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.ZIP64_CENTRAL_DIR;
-    } });
-    Object.defineProperty(exports2, "GP_FLAG", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "GP_FLAG", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.GP_FLAG;
-    } });
-    Object.defineProperty(exports2, "TIMESTAMP_SUBMITTED", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "TIMESTAMP_SUBMITTED", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.TIMESTAMP_SUBMITTED;
-    } });
-    Object.defineProperty(exports2, "TIMESTAMP_METADATA", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "TIMESTAMP_METADATA", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.TIMESTAMP_METADATA;
-    } });
-    Object.defineProperty(exports2, "TOKENIZED_METADATA", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "TOKENIZED_METADATA", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.TOKENIZED_METADATA;
-    } });
-    Object.defineProperty(exports2, "LOCAL_FILE_HEADER", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "LOCAL_FILE_HEADER", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.LOCAL_FILE_HEADER;
-    } });
-    Object.defineProperty(exports2, "CENTRAL_FILE_HEADER", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CENTRAL_FILE_HEADER", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.CENTRAL_FILE_HEADER;
-    } });
-    Object.defineProperty(exports2, "CENTRAL_DIRECTORY_END", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CENTRAL_DIRECTORY_END", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.CENTRAL_DIRECTORY_END;
-    } });
-    Object.defineProperty(exports2, "HDR_ID", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "HDR_ID", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Headers_1.HDR_ID;
-    } });
+    }, "get") });
     var Zipkit = class {
       static {
         __name(this, "Zipkit");
@@ -10533,9 +11458,9 @@ var require_Zipkit = __commonJS({
   }
 });
 
-// neozipkit/dist/core/components/Support.js
+// node_modules/neozipkit/dist/core/components/Support.js
 var require_Support = __commonJS({
-  "neozipkit/dist/core/components/Support.js"(exports2) {
+  "node_modules/neozipkit/dist/core/components/Support.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     var Support = {
@@ -10588,9 +11513,9 @@ var require_Support = __commonJS({
   }
 });
 
-// neozipkit/dist/core/components/Util.js
+// node_modules/neozipkit/dist/core/components/Util.js
 var require_Util = __commonJS({
-  "neozipkit/dist/core/components/Util.js"(exports2) {
+  "node_modules/neozipkit/dist/core/components/Util.js"(exports2) {
     "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -10664,9 +11589,9 @@ var require_Util = __commonJS({
   }
 });
 
-// neozipkit/dist/core/components/ProgressTracker.js
+// node_modules/neozipkit/dist/core/components/ProgressTracker.js
 var require_ProgressTracker = __commonJS({
-  "neozipkit/dist/core/components/ProgressTracker.js"(exports2) {
+  "node_modules/neozipkit/dist/core/components/ProgressTracker.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ProgressTracker = void 0;
@@ -10772,9 +11697,9 @@ var require_ProgressTracker = __commonJS({
   }
 });
 
-// neozipkit/dist/core/encryption/Manager.js
+// node_modules/neozipkit/dist/core/encryption/Manager.js
 var require_Manager = __commonJS({
-  "neozipkit/dist/core/encryption/Manager.js"(exports2) {
+  "node_modules/neozipkit/dist/core/encryption/Manager.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.EncryptionManager = void 0;
@@ -10895,45 +11820,41 @@ var require_Manager = __commonJS({
   }
 });
 
-// neozipkit/dist/core/version.js
+// node_modules/neozipkit/dist/core/version.js
 var require_version = __commonJS({
-  "neozipkit/dist/core/version.js"(exports2) {
+  "node_modules/neozipkit/dist/core/version.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.VERSION = void 0;
     var currentDate = /* @__PURE__ */ new Date();
     var releaseDate = `${String(currentDate.getMonth() + 1).padStart(2, "0")}-${String(currentDate.getDate()).padStart(2, "0")}-${currentDate.getFullYear()}`;
     exports2.VERSION = {
-      number: "0.3.0",
+      number: "0.3.1",
       // packageJson.version,
       date: releaseDate
     };
   }
 });
 
-// neozipkit/dist/core/index.js
+// node_modules/neozipkit/dist/core/index.js
 var require_core = __commonJS({
-  "neozipkit/dist/core/index.js"(exports2) {
+  "node_modules/neozipkit/dist/core/index.js"(exports2) {
     "use strict";
-    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
       var desc = Object.getOwnPropertyDescriptor(m, k);
       if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
+        desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
           return m[k];
-        } };
+        }, "get") };
       }
       Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
       o[k2] = m[k];
-    });
+    }));
     var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m)
-        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
-          __createBinding2(exports3, m, p);
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding2(exports3, m, p);
     };
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
@@ -10944,59 +11865,59 @@ var require_core = __commonJS({
     __exportStar2(require_Zipkit(), exports2);
     __exportStar2(require_ZipEntry(), exports2);
     var ZipCompress_1 = require_ZipCompress();
-    Object.defineProperty(exports2, "ZipCompress", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ZipCompress", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipCompress_1.ZipCompress;
-    } });
+    }, "get") });
     exports2.default = Zipkit_1.default;
     var HashCalculator_1 = require_HashCalculator();
-    Object.defineProperty(exports2, "HashCalculator", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "HashCalculator", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return __importDefault(HashCalculator_1).default;
-    } });
-    Object.defineProperty(exports2, "HashCalculatorClass", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "HashCalculatorClass", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return HashCalculator_1.HashCalculator;
-    } });
+    }, "get") });
     __exportStar2(require_Util(), exports2);
     __exportStar2(require_Support(), exports2);
     var ProgressTracker_1 = require_ProgressTracker();
-    Object.defineProperty(exports2, "ProgressTracker", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ProgressTracker", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ProgressTracker_1.ProgressTracker;
-    } });
+    }, "get") });
     var Manager_1 = require_Manager();
-    Object.defineProperty(exports2, "EncryptionManager", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "EncryptionManager", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Manager_1.EncryptionManager;
-    } });
+    }, "get") });
     var ZipCrypto_1 = require_ZipCrypto();
-    Object.defineProperty(exports2, "ZipCrypto", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ZipCrypto", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipCrypto_1.ZipCrypto;
-    } });
-    Object.defineProperty(exports2, "crc32", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "crc32", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipCrypto_1.crc32;
-    } });
-    Object.defineProperty(exports2, "crc32update", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "crc32update", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipCrypto_1.crc32update;
-    } });
-    Object.defineProperty(exports2, "sha256", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "sha256", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipCrypto_1.sha256;
-    } });
+    }, "get") });
     __exportStar2(require_types(), exports2);
     __exportStar2(require_Headers(), exports2);
     __exportStar2(require_Errors(), exports2);
     __exportStar2(require_version(), exports2);
     var Logger_1 = require_Logger();
-    Object.defineProperty(exports2, "Logger", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "Logger", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Logger_1.Logger;
-    } });
-    Object.defineProperty(exports2, "configureLoggerFromEnvironment", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "configureLoggerFromEnvironment", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return Logger_1.configureLoggerFromEnvironment;
-    } });
+    }, "get") });
   }
 });
 
-// neozipkit/dist/blockchain/core/ZipkitOTS.js
+// node_modules/neozipkit/dist/blockchain/core/ZipkitOTS.js
 var require_ZipkitOTS = __commonJS({
-  "neozipkit/dist/blockchain/core/ZipkitOTS.js"(exports2) {
-    "use strict";
+  "node_modules/neozipkit/dist/blockchain/core/ZipkitOTS.js"(exports2) {
     "use server";
+    "use strict";
     var __importDefault = exports2 && exports2.__importDefault || function(mod) {
       return mod && mod.__esModule ? mod : { "default": mod };
     };
@@ -11375,128 +12296,124 @@ var require_ZipkitOTS = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/core/index.js
+// node_modules/neozipkit/dist/blockchain/core/index.js
 var require_core2 = __commonJS({
-  "neozipkit/dist/blockchain/core/index.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/core/index.js"(exports2) {
     "use strict";
-    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
       var desc = Object.getOwnPropertyDescriptor(m, k);
       if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
+        desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
           return m[k];
-        } };
+        }, "get") };
       }
       Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
       o[k2] = m[k];
-    });
+    }));
     var __exportStar2 = exports2 && exports2.__exportStar || function(m, exports3) {
-      for (var p in m)
-        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p))
-          __createBinding2(exports3, m, p);
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding2(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.verifyOtsZip = exports2.verifyOts = exports2.getMerkleRootSafe = exports2.getOtsBuffer = exports2.getOtsEntry = exports2.bufferToArrayBuffer = exports2.createOtsMetadataEntry = exports2.upgradeOTS = exports2.parseVerifyResult = exports2.deserializeOts = exports2.createTimestamp = exports2.normalizeNetworkName = exports2.getNetworkByName = exports2.getSupportedNetworkNames = exports2.getChainIdByName = exports2.isNetworkSupported = exports2.getSupportedNetworks = exports2.getContractConfig = exports2.DEFAULT_NETWORK = exports2.CURRENT_DEPLOYMENT = exports2.CONTRACT_CONFIGS = exports2.NZIP_CONTRACT_ABI_WEB3 = exports2.NZIP_CONTRACT_ABI = exports2.WalletAnalyzer = exports2.CoreWalletManager = exports2.ZipkitVerifier = exports2.validatePrivateKey = exports2.ZipkitMinter = void 0;
     __exportStar2(require_types(), exports2);
     var ZipkitMinter_1 = require_ZipkitMinter();
-    Object.defineProperty(exports2, "ZipkitMinter", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ZipkitMinter", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitMinter_1.ZipkitMinter;
-    } });
-    Object.defineProperty(exports2, "validatePrivateKey", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "validatePrivateKey", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitMinter_1.validatePrivateKey;
-    } });
+    }, "get") });
     var ZipkitVerifier_1 = require_ZipkitVerifier();
-    Object.defineProperty(exports2, "ZipkitVerifier", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ZipkitVerifier", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitVerifier_1.ZipkitVerifier;
-    } });
+    }, "get") });
     var WalletManager_1 = require_WalletManager();
-    Object.defineProperty(exports2, "CoreWalletManager", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "CoreWalletManager", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return WalletManager_1.CoreWalletManager;
-    } });
-    Object.defineProperty(exports2, "WalletAnalyzer", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "WalletAnalyzer", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return WalletManager_1.WalletAnalyzer;
-    } });
+    }, "get") });
     var contracts_1 = require_contracts();
-    Object.defineProperty(exports2, "NZIP_CONTRACT_ABI", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "NZIP_CONTRACT_ABI", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.NZIP_CONTRACT_ABI;
-    } });
-    Object.defineProperty(exports2, "NZIP_CONTRACT_ABI_WEB3", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "NZIP_CONTRACT_ABI_WEB3", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.NZIP_CONTRACT_ABI_WEB3;
-    } });
-    Object.defineProperty(exports2, "CONTRACT_CONFIGS", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CONTRACT_CONFIGS", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.CONTRACT_CONFIGS;
-    } });
-    Object.defineProperty(exports2, "CURRENT_DEPLOYMENT", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CURRENT_DEPLOYMENT", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.CURRENT_DEPLOYMENT;
-    } });
-    Object.defineProperty(exports2, "DEFAULT_NETWORK", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "DEFAULT_NETWORK", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.DEFAULT_NETWORK;
-    } });
-    Object.defineProperty(exports2, "getContractConfig", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getContractConfig", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.getContractConfig;
-    } });
-    Object.defineProperty(exports2, "getSupportedNetworks", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getSupportedNetworks", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.getSupportedNetworks;
-    } });
-    Object.defineProperty(exports2, "isNetworkSupported", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "isNetworkSupported", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.isNetworkSupported;
-    } });
-    Object.defineProperty(exports2, "getChainIdByName", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getChainIdByName", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.getChainIdByName;
-    } });
-    Object.defineProperty(exports2, "getSupportedNetworkNames", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getSupportedNetworkNames", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.getSupportedNetworkNames;
-    } });
-    Object.defineProperty(exports2, "getNetworkByName", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getNetworkByName", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.getNetworkByName;
-    } });
-    Object.defineProperty(exports2, "normalizeNetworkName", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "normalizeNetworkName", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return contracts_1.normalizeNetworkName;
-    } });
+    }, "get") });
     var ZipkitOTS_1 = require_ZipkitOTS();
-    Object.defineProperty(exports2, "createTimestamp", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "createTimestamp", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.createTimestamp;
-    } });
-    Object.defineProperty(exports2, "deserializeOts", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "deserializeOts", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.deserializeOts;
-    } });
-    Object.defineProperty(exports2, "parseVerifyResult", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "parseVerifyResult", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.parseVerifyResult;
-    } });
-    Object.defineProperty(exports2, "upgradeOTS", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "upgradeOTS", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.upgradeOTS;
-    } });
-    Object.defineProperty(exports2, "createOtsMetadataEntry", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "createOtsMetadataEntry", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.createOtsMetadataEntry;
-    } });
-    Object.defineProperty(exports2, "bufferToArrayBuffer", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "bufferToArrayBuffer", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.bufferToArrayBuffer;
-    } });
-    Object.defineProperty(exports2, "getOtsEntry", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getOtsEntry", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.getOtsEntry;
-    } });
-    Object.defineProperty(exports2, "getOtsBuffer", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getOtsBuffer", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.getOtsBuffer;
-    } });
-    Object.defineProperty(exports2, "getMerkleRootSafe", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "getMerkleRootSafe", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.getMerkleRootSafe;
-    } });
-    Object.defineProperty(exports2, "verifyOts", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "verifyOts", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.verifyOts;
-    } });
-    Object.defineProperty(exports2, "verifyOtsZip", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "verifyOtsZip", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitOTS_1.verifyOtsZip;
-    } });
+    }, "get") });
   }
 });
 
-// neozipkit/dist/blockchain/browser/WalletManagerBrowser.js
+// node_modules/neozipkit/dist/blockchain/browser/WalletManagerBrowser.js
 var require_WalletManagerBrowser = __commonJS({
-  "neozipkit/dist/blockchain/browser/WalletManagerBrowser.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/browser/WalletManagerBrowser.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.WalletManagerBrowser = void 0;
@@ -11893,18 +12810,20 @@ Network Details:
   }
 });
 
-// neozipkit/dist/blockchain/browser/ZipkitMinterBrowser.js
+// node_modules/neozipkit/dist/blockchain/browser/ZipkitMinterBrowser.js
 var require_ZipkitMinterBrowser = __commonJS({
-  "neozipkit/dist/blockchain/browser/ZipkitMinterBrowser.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/browser/ZipkitMinterBrowser.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.ZipkitMinterBrowser = void 0;
+    var contracts_1 = require_contracts();
     var ZipkitMinterBrowser = class {
       static {
         __name(this, "ZipkitMinterBrowser");
       }
-      constructor(merkleRoot, walletManager) {
+      constructor(merkleRoot, walletManager, encryptedHash) {
         this.merkleRoot = merkleRoot;
+        this.encryptedHash = encryptedHash || "";
         this.walletManager = walletManager;
       }
       /**
@@ -11976,9 +12895,14 @@ var require_ZipkitMinterBrowser = __commonJS({
           const creationTimestamp = Math.floor(Date.now() / 1e3);
           const ipfsHash = "";
           const tokenURI = "";
+          const config = this.walletManager.getCurrentConfig();
+          if (!config.version) {
+            throw new Error(`Contract version not specified for network ${config.network}`);
+          }
+          const adapter = (0, contracts_1.getContractAdapterByVersion)(config.version);
           const GAS_ESTIMATION_TIMEOUT = 3e4;
           const gasEstimate = await Promise.race([
-            contractWithSigner.getFunction("publicMintZipFile").estimateGas(this.merkleRoot, creationTimestamp, ipfsHash, tokenURI),
+            adapter.estimateGasForMint(contractWithSigner, this.merkleRoot, this.encryptedHash || void 0, creationTimestamp, ipfsHash, tokenURI),
             new Promise((_, reject) => setTimeout(() => reject(new Error("Gas estimation timeout")), GAS_ESTIMATION_TIMEOUT))
           ]);
           const readProvider = this.walletManager.getReadProvider();
@@ -12026,16 +12950,19 @@ var require_ZipkitMinterBrowser = __commonJS({
           console.log("\u{1F4E1} Submitting transaction to blockchain...");
           console.log(`\u{1F550} Creation timestamp: ${creationTimestamp}`);
           console.log("\u{1F512} Note: Filename is not stored on blockchain for privacy");
-          const functionCall = contractWithSigner.getFunction("publicMintZipFile");
+          if (!config.version) {
+            throw new Error(`Contract version not specified for network ${config.network}`);
+          }
+          const adapter = (0, contracts_1.getContractAdapterByVersion)(config.version);
           const TX_SEND_TIMEOUT = 6e4;
           console.log("\u23F3 Waiting for wallet approval...");
           const tx = await Promise.race([
-            functionCall(this.merkleRoot, creationTimestamp, ipfsHash, tokenURI),
+            adapter.mintZipFile(contractWithSigner, this.merkleRoot, this.encryptedHash || void 0, creationTimestamp, ipfsHash, tokenURI),
             new Promise((_, reject) => setTimeout(() => reject(new Error("Transaction send timeout - wallet approval dialog may not have appeared. Please check your wallet.")), TX_SEND_TIMEOUT))
           ]);
           console.log(`\u{1F4DC} Transaction submitted: ${tx.hash}`);
           console.log("\u23F3 Waiting for confirmation...");
-          let receipt;
+          let receipt = null;
           const CONFIRMATION_TIMEOUT = 12e4;
           try {
             const readProvider = this.walletManager.getReadProvider();
@@ -12066,40 +12993,45 @@ var require_ZipkitMinterBrowser = __commonJS({
               throw confirmationError;
             }
           }
-          console.log(`\u2705 Transaction confirmed in block: ${receipt?.blockNumber}`);
+          if (!receipt) {
+            throw new Error("Transaction receipt not available");
+          }
+          console.log(`\u2705 Transaction confirmed in block: ${receipt.blockNumber}`);
           let tokenId;
-          for (let i = 0; i < receipt.logs.length; i++) {
-            const log = receipt.logs[i];
-            try {
-              const parsed = contract.interface.parseLog(log);
-              if (parsed) {
-                if (parsed.name === "ZipFileTokenized") {
-                  tokenId = parsed.args.tokenId.toString();
-                  break;
-                } else if (parsed.name === "Transfer") {
-                  const from = parsed.args.from;
-                  const transferTokenId = parsed.args.tokenId;
-                  if (from === "0x0000000000000000000000000000000000000000") {
-                    tokenId = transferTokenId.toString();
+          if (receipt.logs && Array.isArray(receipt.logs)) {
+            for (let i = 0; i < receipt.logs.length; i++) {
+              const log = receipt.logs[i];
+              try {
+                const parsed = contract.interface.parseLog(log);
+                if (parsed) {
+                  if (parsed.name === "ZipFileTokenized") {
+                    tokenId = parsed.args.tokenId.toString();
                     break;
+                  } else if (parsed.name === "Transfer") {
+                    const from = parsed.args.from;
+                    const transferTokenId = parsed.args.tokenId;
+                    if (from === "0x0000000000000000000000000000000000000000") {
+                      tokenId = transferTokenId.toString();
+                      break;
+                    }
                   }
                 }
-              }
-            } catch (parseError) {
-              console.warn(`\u26A0\uFE0F Could not parse log ${i}:`, parseError);
-              if (log.topics.length >= 4 && log.topics[0] === "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") {
-                try {
-                  const from = log.topics[1];
-                  const to = log.topics[2];
-                  const transferTokenId = log.topics[3];
-                  console.log(`\u{1F504} Manual Transfer parse: from=${from}, to=${to}, tokenId=${transferTokenId}`);
-                  if (from === "0x0000000000000000000000000000000000000000000000000000000000000000") {
-                    tokenId = parseInt(transferTokenId, 16).toString();
-                    console.log(`\u{1F3AF} Found minting via manual parse with token ID: ${tokenId}`);
-                    break;
+              } catch (parseError) {
+                console.warn(`\u26A0\uFE0F Could not parse log ${i}:`, parseError);
+                if (log.topics && log.topics.length >= 4 && log.topics[0] === "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef") {
+                  try {
+                    const from = log.topics[1];
+                    const to = log.topics[2];
+                    const transferTokenId = log.topics[3];
+                    console.log(`\u{1F504} Manual Transfer parse: from=${from}, to=${to}, tokenId=${transferTokenId}`);
+                    if (from === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+                      tokenId = parseInt(transferTokenId, 16).toString();
+                      console.log(`\u{1F3AF} Found minting via manual parse with token ID: ${tokenId}`);
+                      break;
+                    }
+                  } catch (manualParseError) {
+                    console.warn(`\u26A0\uFE0F Manual parsing also failed:`, manualParseError);
                   }
-                } catch (manualParseError) {
-                  console.warn(`\u26A0\uFE0F Manual parsing also failed:`, manualParseError);
                 }
               }
             }
@@ -12141,16 +13073,21 @@ var require_ZipkitMinterBrowser = __commonJS({
       createTokenMetadata(tokenId, transactionHash) {
         const now = /* @__PURE__ */ new Date();
         const config = this.walletManager.getCurrentConfig();
+        if (!config.version) {
+          throw new Error(`Contract version not specified for network ${config.network} (chainId: ${config.chainId})`);
+        }
         return {
-          version: "1.0",
           tokenId,
           contractAddress: config.address,
           network: config.network,
           networkChainId: config.chainId,
           transactionHash,
           merkleRoot: this.merkleRoot,
+          encryptedHash: this.encryptedHash || void 0,
           mintedAt: now.toISOString(),
-          creationTimestamp: Math.floor(now.getTime() / 1e3)
+          creationTimestamp: Math.floor(now.getTime() / 1e3),
+          contractVersion: config.version
+          // Required - always set from config
         };
       }
       /**
@@ -12176,9 +13113,9 @@ var require_ZipkitMinterBrowser = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/browser/TokenVerifierBrowser.js
+// node_modules/neozipkit/dist/blockchain/browser/TokenVerifierBrowser.js
 var require_TokenVerifierBrowser = __commonJS({
-  "neozipkit/dist/blockchain/browser/TokenVerifierBrowser.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/browser/TokenVerifierBrowser.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.TokenVerifierBrowser = void 0;
@@ -12273,9 +13210,6 @@ var require_TokenVerifierBrowser = __commonJS({
           const normalizedBlockchain = blockchainData.merkleRoot?.toLowerCase().trim() || "";
           const normalizedCalculated = calculatedMerkleRoot?.toLowerCase().trim() || "";
           const verificationPassed = normalizedBlockchain === normalizedCalculated;
-          if (!verificationPassed) {
-            console.warn(`[TokenVerifier] \u26A0\uFE0F Merkle root mismatch - Calculated: ${calculatedMerkleRoot}, Blockchain: ${blockchainData.merkleRoot}`);
-          }
           const enhancedTokenMetadata = {
             ...tokenMetadata,
             owner: blockchainData.owner || void 0
@@ -12302,9 +13236,31 @@ var require_TokenVerifierBrowser = __commonJS({
       }
       /**
        * Validates token metadata structure
+       * Validates required fields: tokenId, contractAddress, network, merkleRoot, networkChainId, contractVersion
        */
       validateTokenInfo(tokenMetadata) {
-        return tokenMetadata && typeof tokenMetadata.version === "string" && typeof tokenMetadata.tokenId === "string" && typeof tokenMetadata.contractAddress === "string" && typeof tokenMetadata.network === "string" && typeof tokenMetadata.networkChainId === "number" && typeof tokenMetadata.transactionHash === "string" && typeof tokenMetadata.merkleRoot === "string" && typeof tokenMetadata.mintedAt === "string";
+        if (!tokenMetadata || typeof tokenMetadata !== "object") {
+          return false;
+        }
+        if (typeof tokenMetadata.tokenId !== "string" || !tokenMetadata.tokenId) {
+          return false;
+        }
+        if (typeof tokenMetadata.contractAddress !== "string" || !tokenMetadata.contractAddress) {
+          return false;
+        }
+        if (typeof tokenMetadata.network !== "string" || !tokenMetadata.network) {
+          return false;
+        }
+        if (typeof tokenMetadata.merkleRoot !== "string" || !tokenMetadata.merkleRoot) {
+          return false;
+        }
+        if (typeof tokenMetadata.networkChainId !== "number" || tokenMetadata.networkChainId === void 0) {
+          return false;
+        }
+        if (typeof tokenMetadata.contractVersion !== "string" || !tokenMetadata.contractVersion) {
+          return false;
+        }
+        return true;
       }
       /**
        * Calculates the merkle root excluding the token metadata file
@@ -12391,9 +13347,11 @@ var require_TokenVerifierBrowser = __commonJS({
               const contract = new ethers_1.ethers.Contract(tokenMetadata.contractAddress, CONTRACT_ABI, provider);
               const zipInfo = await contract.getZipFileInfo(tokenMetadata.tokenId);
               const owner = await contract.ownerOf(tokenMetadata.tokenId);
+              const merkleRoot = zipInfo.merkleRootHash;
+              const timestamp = Number(zipInfo.tokenizationTime);
               return {
-                merkleRoot: zipInfo.merkleRootHash,
-                timestamp: Number(zipInfo.tokenizationTime),
+                merkleRoot,
+                timestamp,
                 owner
               };
             } catch (error) {
@@ -12446,406 +13404,84 @@ var require_TokenVerifierBrowser = __commonJS({
   }
 });
 
-// neozipkit/dist/blockchain/browser/index.js
+// node_modules/neozipkit/dist/blockchain/browser/index.js
 var require_browser = __commonJS({
-  "neozipkit/dist/blockchain/browser/index.js"(exports2) {
+  "node_modules/neozipkit/dist/blockchain/browser/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.checkForTokenization = exports2.createTokenVerifier = exports2.TokenVerifierBrowser = exports2.ZipkitMinterBrowser = exports2.WalletManagerBrowser = void 0;
     var WalletManagerBrowser_1 = require_WalletManagerBrowser();
-    Object.defineProperty(exports2, "WalletManagerBrowser", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "WalletManagerBrowser", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return WalletManagerBrowser_1.WalletManagerBrowser;
-    } });
+    }, "get") });
     var ZipkitMinterBrowser_1 = require_ZipkitMinterBrowser();
-    Object.defineProperty(exports2, "ZipkitMinterBrowser", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ZipkitMinterBrowser", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return ZipkitMinterBrowser_1.ZipkitMinterBrowser;
-    } });
+    }, "get") });
     var TokenVerifierBrowser_1 = require_TokenVerifierBrowser();
-    Object.defineProperty(exports2, "TokenVerifierBrowser", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "TokenVerifierBrowser", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return TokenVerifierBrowser_1.TokenVerifierBrowser;
-    } });
-    Object.defineProperty(exports2, "createTokenVerifier", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "createTokenVerifier", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return TokenVerifierBrowser_1.createTokenVerifier;
-    } });
-    Object.defineProperty(exports2, "checkForTokenization", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "checkForTokenization", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return TokenVerifierBrowser_1.checkForTokenization;
-    } });
-  }
-});
-
-// neozipkit/dist/blockchain/server/ZipkitMinterServer.js
-var require_ZipkitMinterServer = __commonJS({
-  "neozipkit/dist/blockchain/server/ZipkitMinterServer.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ZipkitMinterServer = void 0;
-    var ZipkitMinter_1 = require_ZipkitMinter();
-    var ZipkitMinterServer = class extends ZipkitMinter_1.ZipkitMinter {
-      static {
-        __name(this, "ZipkitMinterServer");
-      }
-      constructor(merkleRoot, options) {
-        super(merkleRoot, options);
-      }
-      /**
-       * Server-specific minting with enhanced error handling
-       */
-      async mintTokenWithRetry(maxRetries = 3) {
-        let lastError = null;
-        for (let attempt = 1; attempt <= maxRetries; attempt++) {
-          try {
-            console.log(`\u{1F504} Minting attempt ${attempt}/${maxRetries}`);
-            const result = await this.mintToken();
-            if (result.success) {
-              console.log(`\u2705 Minting successful on attempt ${attempt}`);
-              return result;
-            }
-            lastError = new Error(result.message || "Minting failed");
-          } catch (error) {
-            lastError = error instanceof Error ? error : new Error("Unknown error");
-            console.warn(`\u274C Minting attempt ${attempt} failed:`, lastError.message);
-            if (attempt < maxRetries) {
-              const delay = Math.pow(2, attempt) * 1e3;
-              console.log(`\u23F3 Waiting ${delay}ms before retry...`);
-              await new Promise((resolve) => setTimeout(resolve, delay));
-            }
-          }
-        }
-        return {
-          success: false,
-          message: `Minting failed after ${maxRetries} attempts: ${lastError?.message || "Unknown error"}`
-        };
-      }
-      /**
-       * Batch minting for multiple archives
-       */
-      async mintBatch(archives) {
-        const results = [];
-        for (const archive of archives) {
-          try {
-            this.merkleRoot = archive.merkleRoot;
-            const result = await this.mintToken();
-            results.push(result);
-            await new Promise((resolve) => setTimeout(resolve, 1e3));
-          } catch (error) {
-            results.push({
-              success: false,
-              message: `Failed to mint ${archive.name}: ${error instanceof Error ? error.message : "Unknown error"}`
-            });
-          }
-        }
-        return results;
-      }
-    };
-    exports2.ZipkitMinterServer = ZipkitMinterServer;
-  }
-});
-
-// neozipkit/dist/blockchain/server/ZipkitVerifierServer.js
-var require_ZipkitVerifierServer = __commonJS({
-  "neozipkit/dist/blockchain/server/ZipkitVerifierServer.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ZipkitVerifierServer = void 0;
-    var ZipkitVerifier_1 = require_ZipkitVerifier();
-    var ZipkitVerifierServer = class extends ZipkitVerifier_1.ZipkitVerifier {
-      static {
-        __name(this, "ZipkitVerifierServer");
-      }
-      constructor(options = {}) {
-        super(options);
-        this.maxRetries = options.maxRetries || 3;
-        this.retryDelay = options.retryDelay || 1e3;
-        this.batchDelay = options.batchDelay || 500;
-      }
-      /**
-       * Server-specific verification with enhanced error handling and retry logic
-       */
-      async verifyTokenWithRetry(tokenId, expectedMerkleRoot, maxRetries) {
-        const startTime = Date.now();
-        const retries = maxRetries || this.maxRetries;
-        let lastError = null;
-        for (let attempt = 1; attempt <= retries; attempt++) {
-          try {
-            console.log(`\u{1F504} Verification attempt ${attempt}/${retries} for token ${tokenId}`);
-            const result = await this.verifyTokenById(tokenId, expectedMerkleRoot);
-            if (result.success) {
-              console.log(`\u2705 Verification successful on attempt ${attempt} for token ${tokenId}`);
-              return {
-                ...result,
-                retryAttempts: attempt,
-                processingTime: Date.now() - startTime,
-                serverTimestamp: Date.now()
-              };
-            }
-            lastError = new Error(result.message || "Verification failed");
-          } catch (error) {
-            lastError = error instanceof Error ? error : new Error("Unknown verification error");
-            console.warn(`\u274C Verification attempt ${attempt} failed for token ${tokenId}:`, lastError.message);
-            if (attempt < retries) {
-              const delay = this.calculateRetryDelay(attempt);
-              console.log(`\u23F3 Waiting ${delay}ms before retry...`);
-              await this.delay(delay);
-            }
-          }
-        }
-        return {
-          success: false,
-          message: `Verification failed after ${retries} attempts: ${lastError?.message || "Unknown error"}`,
-          retryAttempts: retries,
-          processingTime: Date.now() - startTime,
-          serverTimestamp: Date.now()
-        };
-      }
-      /**
-       * Batch verification for multiple tokens with rate limiting
-       */
-      async verifyBatch(tokens, options = {}) {
-        const startTime = Date.now();
-        const { parallel = false, maxConcurrent = 3 } = options;
-        console.log(`\u{1F504} Starting batch verification for ${tokens.length} tokens (parallel: ${parallel})`);
-        let results = [];
-        if (parallel) {
-          results = await this.verifyBatchParallel(tokens, maxConcurrent);
-        } else {
-          results = await this.verifyBatchSequential(tokens);
-        }
-        const successfulVerifications = results.filter((r) => r.success).length;
-        const failedVerifications = results.length - successfulVerifications;
-        console.log(`\u2705 Batch verification completed: ${successfulVerifications}/${tokens.length} successful`);
-        return {
-          success: failedVerifications === 0,
-          totalTokens: tokens.length,
-          successfulVerifications,
-          failedVerifications,
-          results,
-          processingTime: Date.now() - startTime
-        };
-      }
-      /**
-       * Verify tokens in parallel with concurrency control
-       */
-      async verifyBatchParallel(tokens, maxConcurrent) {
-        const results = [];
-        const chunks = [];
-        for (let i = 0; i < tokens.length; i += maxConcurrent) {
-          chunks.push(tokens.slice(i, i + maxConcurrent));
-        }
-        for (const chunk of chunks) {
-          const chunkPromises = chunk.map((token) => this.verifyTokenWithRetry(token.tokenId, token.merkleRoot));
-          const chunkResults = await Promise.all(chunkPromises);
-          results.push(...chunkResults);
-          if (chunks.indexOf(chunk) < chunks.length - 1) {
-            await this.delay(this.batchDelay);
-          }
-        }
-        return results;
-      }
-      /**
-       * Verify tokens sequentially with rate limiting
-       */
-      async verifyBatchSequential(tokens) {
-        const results = [];
-        for (const token of tokens) {
-          const result = await this.verifyTokenWithRetry(token.tokenId, token.merkleRoot);
-          results.push(result);
-          if (tokens.indexOf(token) < tokens.length - 1) {
-            await this.delay(this.batchDelay);
-          }
-        }
-        return results;
-      }
-      /**
-       * Verify a token by ID (server-specific implementation)
-       */
-      async verifyTokenById(tokenId, expectedMerkleRoot) {
-        try {
-          const tokenMetadata = await this.getTokenMetadata(tokenId);
-          if (!tokenMetadata) {
-            return {
-              success: false,
-              message: `Token ${tokenId} not found or metadata unavailable`
-            };
-          }
-          return await this.verifyToken(tokenMetadata, expectedMerkleRoot || tokenMetadata.merkleRoot);
-        } catch (error) {
-          console.error(`Token verification failed for ${tokenId}:`, error);
-          return {
-            success: false,
-            message: `Token verification failed: ${error instanceof Error ? error.message : "Unknown error"}`
-          };
-        }
-      }
-      /**
-       * Get token metadata from contract
-       */
-      async getTokenMetadata(tokenId) {
-        try {
-          return {
-            tokenId,
-            merkleRoot: "",
-            // Would be fetched from contract
-            mintedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            contractAddress: "",
-            // Would be fetched from contract
-            network: "unknown"
-          };
-        } catch (error) {
-          console.error(`Failed to get metadata for token ${tokenId}:`, error);
-          return null;
-        }
-      }
-      /**
-       * Verify a single token with enhanced error handling
-       */
-      async verifyTokenEnhanced(tokenId, expectedMerkleRoot) {
-        const startTime = Date.now();
-        try {
-          console.log(`\u{1F50D} Starting enhanced verification for token ${tokenId}`);
-          const result = await this.verifyTokenById(tokenId, expectedMerkleRoot);
-          return {
-            ...result,
-            retryAttempts: 1,
-            processingTime: Date.now() - startTime,
-            serverTimestamp: Date.now()
-          };
-        } catch (error) {
-          console.error(`\u274C Enhanced verification failed for token ${tokenId}:`, error);
-          return {
-            success: false,
-            message: `Enhanced verification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-            retryAttempts: 1,
-            processingTime: Date.now() - startTime,
-            serverTimestamp: Date.now()
-          };
-        }
-      }
-      /**
-       * Process verification jobs with priority queue
-       */
-      async processVerificationJobs(jobs, options = {}) {
-        const { maxConcurrent = 3, priorityOrder = true } = options;
-        const sortedJobs = priorityOrder ? this.sortJobsByPriority(jobs) : jobs;
-        const tokens = sortedJobs.map((job) => ({
-          tokenId: job.tokenId,
-          merkleRoot: job.merkleRoot
-        }));
-        return this.verifyBatch(tokens, { parallel: true, maxConcurrent });
-      }
-      /**
-       * Sort verification jobs by priority
-       */
-      sortJobsByPriority(jobs) {
-        const priorityOrder = { high: 0, normal: 1, low: 2 };
-        return jobs.sort((a, b) => {
-          const aPriority = priorityOrder[a.priority || "normal"];
-          const bPriority = priorityOrder[b.priority || "normal"];
-          if (aPriority !== bPriority) {
-            return aPriority - bPriority;
-          }
-          return (a.retryCount || 0) - (b.retryCount || 0);
-        });
-      }
-      /**
-       * Calculate retry delay with exponential backoff
-       */
-      calculateRetryDelay(attempt) {
-        return Math.min(this.retryDelay * Math.pow(2, attempt - 1), 3e4);
-      }
-      /**
-       * Utility method for delays
-       */
-      async delay(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-      }
-      /**
-       * Get verification statistics
-       */
-      getVerificationStats() {
-        return {
-          maxRetries: this.maxRetries,
-          retryDelay: this.retryDelay,
-          batchDelay: this.batchDelay
-        };
-      }
-      /**
-       * Update verification configuration
-       */
-      updateConfig(config) {
-        if (config.maxRetries !== void 0) {
-          this.maxRetries = config.maxRetries;
-        }
-        if (config.retryDelay !== void 0) {
-          this.retryDelay = config.retryDelay;
-        }
-        if (config.batchDelay !== void 0) {
-          this.batchDelay = config.batchDelay;
-        }
-        console.log("\u{1F527} ServerZipkitVerifier configuration updated:", this.getVerificationStats());
-      }
-    };
-    exports2.ZipkitVerifierServer = ZipkitVerifierServer;
+    }, "get") });
   }
 });
 
-// neozipkit/dist/blockchain/server/WalletManagerServer.js
-var require_WalletManagerServer = __commonJS({
-  "neozipkit/dist/blockchain/server/WalletManagerServer.js"(exports2) {
+// node_modules/neozipkit/dist/blockchain/node/WalletManagerNode.js
+var require_WalletManagerNode = __commonJS({
+  "node_modules/neozipkit/dist/blockchain/node/WalletManagerNode.js"(exports2) {
     "use strict";
-    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
+    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
       var desc = Object.getOwnPropertyDescriptor(m, k);
       if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
+        desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
           return m[k];
-        } };
+        }, "get") };
       }
       Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0)
-        k2 = k;
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
       o[k2] = m[k];
-    });
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
       Object.defineProperty(o, "default", { enumerable: true, value: v });
-    } : function(o, v) {
+    }) : function(o, v) {
       o["default"] = v;
     });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
       var ownKeys = /* @__PURE__ */ __name(function(o) {
         ownKeys = Object.getOwnPropertyNames || function(o2) {
           var ar = [];
-          for (var k in o2)
-            if (Object.prototype.hasOwnProperty.call(o2, k))
-              ar[ar.length] = k;
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
           return ar;
         };
         return ownKeys(o);
       }, "ownKeys");
       return function(mod) {
-        if (mod && mod.__esModule)
-          return 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")
-              __createBinding2(result, mod, k[i]);
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding2(result, mod, k[i]);
         }
         __setModuleDefault(result, mod);
         return result;
       };
-    }();
+    })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.ZipkitWallet = exports2.WalletManagerServer = void 0;
+    exports2.ZipkitWallet = exports2.WalletManagerNode = void 0;
     var fs = __importStar(require("fs"));
     var path = __importStar(require("path"));
     var ethers_1 = require("ethers");
     var WalletManager_1 = require_WalletManager();
     var Logger_1 = require_Logger();
-    var WalletManagerServer = class extends WalletManager_1.CoreWalletManager {
+    var WalletManagerNode = class extends WalletManager_1.CoreWalletManager {
       static {
-        __name(this, "WalletManagerServer");
+        __name(this, "WalletManagerNode");
       }
       constructor() {
         super();
@@ -12916,6 +13552,12 @@ var require_WalletManagerServer = __commonJS({
       }
       /**
        * Load wallet from file
+       *
+       * SECURITY WARNING: This method reads private keys from disk.
+       * - Only use for development/testing
+       * - Wallet files are automatically excluded from git via .gitignore
+       * - Wallet files are excluded from NPM packages via .npmignore
+       * - Use secure key management (HSMs, KMS) for production
        */
       loadWalletFromFile(filePath) {
         try {
@@ -12941,6 +13583,13 @@ var require_WalletManagerServer = __commonJS({
       }
       /**
        * Create a new wallet and save to file
+       *
+       * SECURITY WARNING: This method saves private keys to disk.
+       * - Only use for development/testing
+       * - Never commit wallet files to version control
+       * - Use secure key management for production
+       * - Wallet files are automatically excluded via .gitignore and .npmignore
+       * - Protect file system permissions on wallet files
        */
       async createNewWallet() {
         Logger_1.Logger.log("Creating a new wallet...");
@@ -12957,7 +13606,10 @@ var require_WalletManagerServer = __commonJS({
         fs.writeFileSync(walletFilePath, JSON.stringify(walletInfo, null, 2));
         Logger_1.Logger.log(`New wallet created and saved to ${walletFilePath}`);
         Logger_1.Logger.log(`Wallet address: ${newWallet.address}`);
-        Logger_1.Logger.log(`IMPORTANT: Please fund this wallet with BASE to use for minting NFTs!`);
+        Logger_1.Logger.log(`IMPORTANT: Please fund this wallet with testnet ETH to use for minting NFTs!`);
+        Logger_1.Logger.log(`SECURITY: Wallet file is automatically excluded from git (.gitignore) and NPM packages (.npmignore)`);
+        Logger_1.Logger.log(`SECURITY: Never commit wallet files to version control`);
+        Logger_1.Logger.log(`SECURITY: Use secure key management (HSMs, KMS) for production applications`);
         return newWallet.privateKey;
       }
       /**
@@ -12976,102 +13628,84 @@ var require_WalletManagerServer = __commonJS({
         return void 0;
       }
     };
-    exports2.WalletManagerServer = WalletManagerServer;
-    exports2.ZipkitWallet = WalletManagerServer;
+    exports2.WalletManagerNode = WalletManagerNode;
+    exports2.ZipkitWallet = WalletManagerNode;
   }
 });
 
-// neozipkit/dist/blockchain/server/index.js
-var require_server = __commonJS({
-  "neozipkit/dist/blockchain/server/index.js"(exports2) {
+// node_modules/neozipkit/dist/blockchain/node/index.js
+var require_node = __commonJS({
+  "node_modules/neozipkit/dist/blockchain/node/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.verifyOtsZip = exports2.verifyOts = exports2.createTimestamp = exports2.WalletAnalyzer = exports2.CoreWalletManager = exports2.ZipkitVerifier = exports2.ZipkitMinter = exports2.ZipkitWallet = exports2.WalletManagerServer = exports2.ZipkitVerifierServer = exports2.ZipkitMinterServer = void 0;
-    var ZipkitMinterServer_1 = require_ZipkitMinterServer();
-    Object.defineProperty(exports2, "ZipkitMinterServer", { enumerable: true, get: function() {
-      return ZipkitMinterServer_1.ZipkitMinterServer;
-    } });
-    var ZipkitVerifierServer_1 = require_ZipkitVerifierServer();
-    Object.defineProperty(exports2, "ZipkitVerifierServer", { enumerable: true, get: function() {
-      return ZipkitVerifierServer_1.ZipkitVerifierServer;
-    } });
-    var WalletManagerServer_1 = require_WalletManagerServer();
-    Object.defineProperty(exports2, "WalletManagerServer", { enumerable: true, get: function() {
-      return WalletManagerServer_1.WalletManagerServer;
-    } });
-    Object.defineProperty(exports2, "ZipkitWallet", { enumerable: true, get: function() {
-      return WalletManagerServer_1.ZipkitWallet;
-    } });
+    exports2.verifyOtsZip = exports2.verifyOts = exports2.createTimestamp = exports2.WalletAnalyzer = exports2.CoreWalletManager = exports2.ZipkitVerifier = exports2.ZipkitMinter = exports2.ZipkitWallet = exports2.WalletManagerNode = void 0;
+    var WalletManagerNode_1 = require_WalletManagerNode();
+    Object.defineProperty(exports2, "WalletManagerNode", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+      return WalletManagerNode_1.WalletManagerNode;
+    }, "get") });
+    Object.defineProperty(exports2, "ZipkitWallet", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+      return WalletManagerNode_1.ZipkitWallet;
+    }, "get") });
     var core_12 = require_core2();
-    Object.defineProperty(exports2, "ZipkitMinter", { enumerable: true, get: function() {
+    Object.defineProperty(exports2, "ZipkitMinter", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.ZipkitMinter;
-    } });
-    Object.defineProperty(exports2, "ZipkitVerifier", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "ZipkitVerifier", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.ZipkitVerifier;
-    } });
-    Object.defineProperty(exports2, "CoreWalletManager", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "CoreWalletManager", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.CoreWalletManager;
-    } });
-    Object.defineProperty(exports2, "WalletAnalyzer", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "WalletAnalyzer", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.WalletAnalyzer;
-    } });
-    Object.defineProperty(exports2, "createTimestamp", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "createTimestamp", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.createTimestamp;
-    } });
-    Object.defineProperty(exports2, "verifyOts", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "verifyOts", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.verifyOts;
-    } });
-    Object.defineProperty(exports2, "verifyOtsZip", { enumerable: true, get: function() {
+    }, "get") });
+    Object.defineProperty(exports2, "verifyOtsZip", { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return core_12.verifyOtsZip;
-    } });
+    }, "get") });
   }
 });
 
-// neozipkit/dist/blockchain/index.js
-var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-  if (k2 === void 0)
-    k2 = k;
+// node_modules/neozipkit/dist/blockchain/index.js
+var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+  if (k2 === void 0) k2 = k;
   var desc = Object.getOwnPropertyDescriptor(m, k);
   if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-    desc = { enumerable: true, get: function() {
+    desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
       return m[k];
-    } };
+    }, "get") };
   }
   Object.defineProperty(o, k2, desc);
-} : function(o, m, k, k2) {
-  if (k2 === void 0)
-    k2 = k;
+}) : (function(o, m, k, k2) {
+  if (k2 === void 0) k2 = k;
   o[k2] = m[k];
-});
+}));
 var __exportStar = exports && exports.__exportStar || function(m, exports2) {
-  for (var p in m)
-    if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
-      __createBinding(exports2, m, p);
+  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configureLoggerFromEnvironment = exports.Logger = exports.ZipkitWallet = exports.WalletManagerServer = exports.ZipkitVerifierServer = exports.ZipkitMinterServer = void 0;
+exports.configureLoggerFromEnvironment = exports.Logger = exports.ZipkitWallet = exports.WalletManagerNode = void 0;
 __exportStar(require_core2(), exports);
 __exportStar(require_browser(), exports);
-var server_1 = require_server();
-Object.defineProperty(exports, "ZipkitMinterServer", { enumerable: true, get: function() {
-  return server_1.ZipkitMinterServer;
-} });
-Object.defineProperty(exports, "ZipkitVerifierServer", { enumerable: true, get: function() {
-  return server_1.ZipkitVerifierServer;
-} });
-Object.defineProperty(exports, "WalletManagerServer", { enumerable: true, get: function() {
-  return server_1.WalletManagerServer;
-} });
-Object.defineProperty(exports, "ZipkitWallet", { enumerable: true, get: function() {
-  return server_1.ZipkitWallet;
-} });
+var node_1 = require_node();
+Object.defineProperty(exports, "WalletManagerNode", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+  return node_1.WalletManagerNode;
+}, "get") });
+Object.defineProperty(exports, "ZipkitWallet", { enumerable: true, get: /* @__PURE__ */ __name(function() {
+  return node_1.ZipkitWallet;
+}, "get") });
 var core_1 = require_core();
-Object.defineProperty(exports, "Logger", { enumerable: true, get: function() {
+Object.defineProperty(exports, "Logger", { enumerable: true, get: /* @__PURE__ */ __name(function() {
   return core_1.Logger;
-} });
-Object.defineProperty(exports, "configureLoggerFromEnvironment", { enumerable: true, get: function() {
+}, "get") });
+Object.defineProperty(exports, "configureLoggerFromEnvironment", { enumerable: true, get: /* @__PURE__ */ __name(function() {
   return core_1.configureLoggerFromEnvironment;
-} });
+}, "get") });
 /*! Bundled license information:
 
 moment/moment.js: