neozipkit 0.1.1 → 0.2.1

package/dist/{server/blockchain/WalletAnalyzer.js → blockchain/ZipKitWallet.js}

@@ -33,11 +33,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletAnalyzer = void 0;
-const ethers_1 = require("ethers");
+exports.WalletAnalyzer = exports.ZipKitWallet = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-// Contract ABI for NZIP tokens
+const readline = __importStar(require("readline"));
+const ethers_1 = require("ethers");
+const types_1 = require("./types");
 const NZIP_CONTRACT_ABI = [
     "function getZipFileInfo(uint256 tokenId) view returns (tuple(string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, address creator))",
     "function ownerOf(uint256 tokenId) view returns (address)",
@@ -47,58 +48,188 @@ const NZIP_CONTRACT_ABI = [
     "function getTokensByMerkleRoot(string merkleRootHash) view returns (uint256[])",
     "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash)"
 ];
-// ERC-20 token ABI for checking other tokens
 const ERC20_ABI = [
     "function balanceOf(address owner) view returns (uint256)",
     "function name() view returns (string)",
     "function symbol() view returns (string)",
     "function decimals() view returns (uint8)"
 ];
-// ERC-721 NFT ABI
 const ERC721_ABI = [
     "function balanceOf(address owner) view returns (uint256)",
     "function name() view returns (string)",
     "function symbol() view returns (string)",
     "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)"
 ];
-class WalletAnalyzer {
-    constructor(provider) {
-        this.provider = provider;
+class ZipKitWallet {
+    constructor() {
+        this.wallet = null;
+        this.provider = null;
     }
-    /**
-     * Get basic wallet information (balance, transaction count, etc.)
-     */
-    async getWalletBasics(address) {
+    async promptUser(question) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        return new Promise((resolve) => {
+            rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+        });
+    }
+    findExistingWallets() {
+        const walletFiles = [];
+        const currentDir = process.cwd();
+        const walletDir = path.join(currentDir, 'wallet');
+        const walletFileNames = ['neozip-wallet.json'];
+        for (const fileName of walletFileNames) {
+            const filePath = path.join(currentDir, fileName);
+            if (fs.existsSync(filePath))
+                walletFiles.push(filePath);
+        }
+        if (fs.existsSync(walletDir)) {
+            for (const fileName of walletFileNames) {
+                const filePath = path.join(walletDir, fileName);
+                if (fs.existsSync(filePath))
+                    walletFiles.push(filePath);
+            }
+        }
+        return walletFiles;
+    }
+    loadWalletFromFile(filePath) {
         try {
-            // Get ETH balance
-            const balance = await this.provider.getBalance(address);
-            const ethBalance = ethers_1.ethers.formatEther(balance);
-            // Get transaction count (nonce)
-            const txCount = await this.provider.getTransactionCount(address);
-            // Get network info
-            const network = await this.provider.getNetwork();
-            // Get latest block
-            const latestBlock = await this.provider.getBlockNumber();
-            return {
-                ethBalance,
-                transactionCount: txCount,
-                networkName: network.name,
-                chainId: network.chainId,
-                latestBlock
-            };
+            const content = fs.readFileSync(filePath, 'utf8').trim();
+            try {
+                const walletData = JSON.parse(content);
+                if (walletData.privateKey) {
+                    console.log(`Found wallet file: ${filePath}`);
+                    console.log(`Wallet address: ${walletData.address}`);
+                    return walletData.privateKey;
+                }
+            }
+            catch {
+                if (content.startsWith('0x') && content.length === 66) {
+                    console.log(`Found private key file: ${filePath}`);
+                    return content;
+                }
+            }
+            return null;
         }
         catch (error) {
-            throw new Error(`Failed to get wallet basics: ${error}`);
+            console.warn(`Could not read wallet file ${filePath}:`, error);
+            return null;
+        }
+    }
+    async setupWallet(options) {
+        try {
+            const networkConfig = types_1.NETWORKS[options.network] || types_1.NETWORKS['base-sepolia'];
+            let privateKey;
+            if (options.wallet) {
+                const val = options.wallet;
+                if (fs.existsSync(val)) {
+                    const loaded = this.loadWalletFromFile(val);
+                    if (!loaded)
+                        throw new Error(`Could not load valid private key from ${val}`);
+                    privateKey = loaded;
+                }
+                else {
+                    privateKey = val;
+                }
+            }
+            else {
+                const existing = this.findExistingWallets();
+                if (existing.length > 0) {
+                    const selected = existing[0];
+                    const relativePath = path.relative(process.cwd(), selected);
+                    console.log(`Using existing wallet: ${relativePath}`);
+                    const loaded = this.loadWalletFromFile(selected);
+                    if (!loaded)
+                        throw new Error(`Could not load valid private key from ${selected}`);
+                    privateKey = loaded;
+                }
+                else {
+                    console.log('No existing wallet found. Creating new wallet...');
+                    privateKey = await this.createNewWallet();
+                }
+            }
+            this.wallet = new ethers_1.ethers.Wallet(privateKey);
+            console.log(`Using wallet: ${this.wallet.address}`);
+            const ok = await this.connectToNetwork(networkConfig, options.mintToken === true);
+            if (!ok) {
+                return { wallet: null, provider: null, success: false, message: `Failed to connect to ${networkConfig.name} network. Blockchain operations require network connectivity.` };
+            }
+            return { wallet: this.wallet, provider: this.provider, success: true, message: `Wallet setup successful for ${networkConfig.name}` };
+        }
+        catch (error) {
+            console.error('Error setting up wallet:', error);
+            return { wallet: null, provider: null, success: false, message: `Wallet setup failed: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    async createNewWallet() {
+        console.log('Creating a new wallet...');
+        const newWallet = ethers_1.ethers.Wallet.createRandom();
+        const walletInfo = { address: newWallet.address, privateKey: newWallet.privateKey, mnemonic: newWallet.mnemonic?.phrase || "" };
+        const walletDir = path.join(process.cwd(), 'wallet');
+        if (!fs.existsSync(walletDir))
+            fs.mkdirSync(walletDir, { recursive: true });
+        const walletFilePath = path.join(walletDir, 'neozip-wallet.json');
+        fs.writeFileSync(walletFilePath, JSON.stringify(walletInfo, null, 2));
+        console.log(`New wallet created and saved to ${walletFilePath}`);
+        console.log(`Wallet address: ${newWallet.address}`);
+        console.log(`IMPORTANT: Please fund this wallet with BASE to use for minting NFTs!`);
+        return newWallet.privateKey;
+    }
+    async connectToNetwork(networkConfig, mintToken) {
+        try {
+            console.log(`Attempting to connect to ${networkConfig.name} network...`);
+            this.provider = new ethers_1.ethers.JsonRpcProvider(networkConfig.rpcUrl);
+            let networkTimedOut = false;
+            const networkTimeout = setTimeout(() => { networkTimedOut = true; console.error("Network connection timeout"); }, 5000);
+            await Promise.race([
+                this.provider.getNetwork(),
+                new Promise((_, reject) => setTimeout(() => { if (networkTimedOut)
+                    reject(new Error("Network connection timeout")); }, 5100))
+            ]);
+            clearTimeout(networkTimeout);
+            if (this.wallet) {
+                this.wallet = this.wallet.connect(this.provider);
+                const balance = await this.provider.getBalance(this.wallet.address);
+                const balanceEth = ethers_1.ethers.formatEther(balance);
+                console.log(`Wallet balance: ${balanceEth} ETH`);
+                const minBalance = 0.0001;
+                if (parseFloat(balanceEth) < minBalance && mintToken) {
+                    console.error(`ERROR: Insufficient balance (${balanceEth} ETH). Minimum required: ${minBalance} ETH`);
+                    console.error('Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+                    throw new Error(`Insufficient balance for minting. Current: ${balanceEth} ETH, Required: ${minBalance} ETH`);
+                }
+                else if (mintToken) {
+                    console.log(`✅ Sufficient balance for token minting`);
+                }
+            }
+            console.log(`✅ Successfully connected to ${networkConfig.name}`);
+            return true;
+        }
+        catch (networkError) {
+            const errorMessage = networkError instanceof Error ? networkError.message : String(networkError);
+            console.error(`Failed to connect to ${networkConfig.name} network: ${errorMessage}`);
+            this.provider = null;
+            return false;
         }
     }
-    /**
-     * Scan for NZIP tokens owned by an address using multiple methods
-     */
+    getWallet() { return this.wallet; }
+    getProvider() { return this.provider; }
+    isReady() { return this.wallet !== null; }
+    isOnline() { return this.provider !== null; }
+}
+exports.ZipKitWallet = ZipKitWallet;
+class WalletAnalyzer {
+    constructor(provider) { this.provider = provider; }
+    async getWalletBasics(address) {
+        const balance = await this.provider.getBalance(address);
+        const ethBalance = ethers_1.ethers.formatEther(balance);
+        const txCount = await this.provider.getTransactionCount(address);
+        const network = await this.provider.getNetwork();
+        const latestBlock = await this.provider.getBlockNumber();
+        return { ethBalance, transactionCount: txCount, networkName: network.name, chainId: network.chainId, latestBlock };
+    }
     async scanForNZipTokens(contractAddress, ownerAddress) {
         const contract = new ethers_1.ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
         let foundTokens = [];
         let searchMethod = 'none';
-        // Method 1: Try events with recent blocks only
         try {
             const latestBlock = await this.provider.getBlockNumber();
             const startBlock = Math.max(0, latestBlock - 50000);
@@ -107,63 +238,41 @@ class WalletAnalyzer {
             for (const event of events) {
                 if ('args' in event && event.args && event.args.tokenId) {
                     const tokenId = Number(event.args.tokenId);
-                    if (!foundTokens.includes(tokenId)) {
+                    if (!foundTokens.includes(tokenId))
                         foundTokens.push(tokenId);
-                    }
                 }
             }
             if (foundTokens.length > 0) {
-                searchMethod = 'recent-events';
-                return { foundTokens, searchMethod };
+                return { foundTokens, searchMethod: 'recent-events' };
             }
         }
-        catch (eventError) {
-            // Continue to next method
-        }
-        // Method 2: Direct token ID checking (brute force for small supply)
+        catch { }
         try {
             const totalSupply = await contract.totalSupply();
-            const maxCheck = Math.min(Number(totalSupply), 50); // Limit to 50 tokens max
+            const maxCheck = Math.min(Number(totalSupply), 50);
             for (let tokenId = 0; tokenId < maxCheck; tokenId++) {
                 try {
                     const owner = await contract.ownerOf(tokenId);
-                    if (owner.toLowerCase() === ownerAddress.toLowerCase()) {
+                    if (owner.toLowerCase() === ownerAddress.toLowerCase())
                         foundTokens.push(tokenId);
-                    }
-                }
-                catch (ownerError) {
-                    // Token doesn't exist or other error, skip
                 }
+                catch { }
             }
-            if (foundTokens.length > 0) {
-                searchMethod = 'iteration';
-                return { foundTokens, searchMethod };
-            }
+            if (foundTokens.length > 0)
+                return { foundTokens, searchMethod: 'iteration' };
         }
-        catch (iterationError) {
-            // Continue to next method
-        }
-        // Method 3: Check specific token IDs that commonly exist
-        const commonTokenIds = Array.from({ length: 20 }, (_, i) => i); // 0-19
+        catch { }
+        const commonTokenIds = Array.from({ length: 20 }, (_, i) => i);
         for (const tokenId of commonTokenIds) {
             try {
                 const owner = await contract.ownerOf(tokenId);
-                if (owner.toLowerCase() === ownerAddress.toLowerCase()) {
+                if (owner.toLowerCase() === ownerAddress.toLowerCase())
                     foundTokens.push(tokenId);
-                }
             }
-            catch (ownerError) {
-                // Token doesn't exist, skip
-            }
-        }
-        if (foundTokens.length > 0) {
-            searchMethod = 'common-ids';
+            catch { }
         }
-        return { foundTokens, searchMethod };
+        return { foundTokens, searchMethod: foundTokens.length > 0 ? 'common-ids' : 'none' };
     }
-    /**
-     * Get detailed information about NZIP tokens
-     */
     async getNZipTokenDetails(contractAddress, tokenIds) {
         const contract = new ethers_1.ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
         const tokenDetails = [];
@@ -187,30 +296,16 @@ class WalletAnalyzer {
         }
         return tokenDetails;
     }
-    /**
-     * Get contract information (name, symbol, total supply)
-     */
     async getContractInfo(contractAddress) {
         try {
             const contract = new ethers_1.ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
-            const [name, symbol, totalSupply] = await Promise.all([
-                contract.name(),
-                contract.symbol(),
-                contract.totalSupply()
-            ]);
-            return {
-                name,
-                symbol,
-                totalSupply: totalSupply.toString()
-            };
+            const [name, symbol, totalSupply] = await Promise.all([contract.name(), contract.symbol(), contract.totalSupply()]);
+            return { name, symbol, totalSupply: totalSupply.toString() };
         }
-        catch (error) {
+        catch {
             return null;
         }
     }
-    /**
-     * Check ERC-20 token balances for common tokens
-     */
     async checkERC20Tokens(ownerAddress, tokenConfigs) {
         const foundTokens = [];
         for (const tokenConfig of tokenConfigs.filter(t => t.type === 'ERC20')) {
@@ -218,40 +313,19 @@ class WalletAnalyzer {
                 const contract = new ethers_1.ethers.Contract(tokenConfig.address, ERC20_ABI, this.provider);
                 const balance = await contract.balanceOf(ownerAddress);
                 if (balance > 0) {
-                    let name, symbol, decimals;
+                    let name = tokenConfig.name, symbol = tokenConfig.symbol, decimals = 18;
                     try {
-                        [name, symbol, decimals] = await Promise.all([
-                            contract.name(),
-                            contract.symbol(),
-                            contract.decimals()
-                        ]);
-                    }
-                    catch (metadataError) {
-                        // Use fallback info if contract calls fail
-                        name = tokenConfig.name;
-                        symbol = tokenConfig.symbol;
-                        decimals = 18; // Default decimals
+                        [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]);
                     }
+                    catch { }
                     const formattedBalance = ethers_1.ethers.formatUnits(balance, decimals);
-                    foundTokens.push({
-                        address: tokenConfig.address,
-                        name,
-                        symbol,
-                        balance: formattedBalance,
-                        decimals,
-                        type: 'ERC20'
-                    });
+                    foundTokens.push({ address: tokenConfig.address, name, symbol, balance: formattedBalance, decimals, type: 'ERC20' });
                 }
             }
-            catch (error) {
-                // Token might not exist or might not be ERC20, continue silently
-            }
+            catch { }
         }
         return foundTokens;
     }
-    /**
-     * Check NFT collection balances
-     */
     async checkNFTCollections(ownerAddress, nftConfigs) {
         const foundNFTs = [];
         for (const nftConfig of nftConfigs) {
@@ -259,66 +333,30 @@ class WalletAnalyzer {
                 const contract = new ethers_1.ethers.Contract(nftConfig.address, ERC721_ABI, this.provider);
                 const balance = await contract.balanceOf(ownerAddress);
                 if (balance > 0) {
-                    let name, symbol;
+                    let name = nftConfig.name, symbol = nftConfig.symbol;
                     try {
-                        [name, symbol] = await Promise.all([
-                            contract.name(),
-                            contract.symbol()
-                        ]);
-                    }
-                    catch (metadataError) {
-                        name = nftConfig.name;
-                        symbol = nftConfig.symbol;
+                        [name, symbol] = await Promise.all([contract.name(), contract.symbol()]);
                     }
-                    // Try to get token IDs if balance is small
-                    let tokenIds = [];
-                    if (Number(balance) <= 5) {
-                        try {
-                            for (let i = 0; i < Number(balance); i++) {
-                                const tokenId = await contract.tokenOfOwnerByIndex(ownerAddress, i);
-                                tokenIds.push(tokenId.toString());
-                            }
-                        }
-                        catch (enumError) {
-                            // Unable to enumerate, that's okay
-                        }
-                    }
-                    foundNFTs.push({
-                        address: nftConfig.address,
-                        name,
-                        symbol,
-                        balance: balance.toString(),
-                        type: 'ERC721'
-                    });
+                    catch { }
+                    foundNFTs.push({ address: nftConfig.address, name, symbol, balance: balance.toString(), type: 'ERC721' });
                 }
             }
-            catch (error) {
-                // Contract might not exist or might not be ERC-721, continue silently
-            }
+            catch { }
         }
         return foundNFTs;
     }
-    /**
-     * Detect NZIP contract from deployment file
-     */
     static detectNZipContract() {
         const deploymentPath = path.join(process.cwd(), 'zipfile-nft-deployment.json');
         if (fs.existsSync(deploymentPath)) {
             try {
                 const deploymentInfo = JSON.parse(fs.readFileSync(deploymentPath, 'utf8'));
-                if (deploymentInfo.address) {
+                if (deploymentInfo.address)
                     return deploymentInfo.address;
-                }
-            }
-            catch (error) {
-                // Could not read deployment file
             }
+            catch { }
         }
         return undefined;
     }
-    /**
-     * Get common token configurations for a network
-     */
     static getCommonTokens(network) {
         const commonTokens = {
             'base-sepolia': [
@@ -336,16 +374,10 @@ class WalletAnalyzer {
         };
         return commonTokens[network] || [];
     }
-    /**
-     * Get common NFT configurations for a network
-     */
     static getCommonNFTs(network) {
         const commonNFTs = {
-            'base-sepolia': [
-            // Add known testnet NFTs here when they become available
-            ],
+            'base-sepolia': [],
             'base': [
-                // Base mainnet NFTs - these are examples, real addresses would be different
                 { address: '0x1234567890123456789012345678901234567890', name: 'Base Punks', symbol: 'BPUNK', type: 'ERC721' },
                 { address: '0x0987654321098765432109876543210987654321', name: 'Base Bears', symbol: 'BBEAR', type: 'ERC721' },
             ]

package/dist/blockchain/contracts.d.ts

@@ -0,0 +1,14 @@
+export interface ContractConfig {
+    address: string;
+    network: string;
+    chainId: number;
+    explorerUrl: string;
+    rpcUrls: string[];
+}
+export declare const CONTRACT_CONFIGS: Record<number, ContractConfig>;
+export declare const NZIP_CONTRACT_ABI: string[];
+export declare const DEFAULT_NETWORK = 84532;
+export declare const CURRENT_DEPLOYMENT: ContractConfig;
+export declare const getContractConfig: (chainId: number) => ContractConfig;
+export declare const getSupportedNetworks: () => number[];
+export declare const isNetworkSupported: (chainId: number) => boolean;

package/dist/blockchain/contracts.js

@@ -0,0 +1,77 @@
+"use strict";
+// Contract addresses and configurations for different networks
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkSupported = exports.getSupportedNetworks = exports.getContractConfig = exports.CURRENT_DEPLOYMENT = exports.DEFAULT_NETWORK = exports.NZIP_CONTRACT_ABI = exports.CONTRACT_CONFIGS = void 0;
+// NZIP NFT Contract configurations by network
+exports.CONTRACT_CONFIGS = {
+    // Base Sepolia (Primary testnet)
+    84532: {
+        address: '0xFD76a5d420704F34d84b0767961835c43D7b30a8', // Production contract v2.0
+        network: 'Base Sepolia',
+        chainId: 84532,
+        explorerUrl: 'https://sepolia.basescan.org',
+        rpcUrls: [
+            'https://sepolia.base.org',
+            'https://base-sepolia.g.alchemy.com/v2/demo',
+            'https://base-sepolia-rpc.publicnode.com'
+        ]
+    },
+    // Base Mainnet (Production)
+    8453: {
+        address: '0x2716c4609fD97DaEdF429BC4B4Ec2faa81e2cC60',
+        network: 'Base Mainnet',
+        chainId: 8453,
+        explorerUrl: 'https://basescan.org',
+        rpcUrls: [
+            'https://mainnet.base.org',
+            'https://base.drpc.org',
+            'https://base.gateway.tenderly.co'
+        ]
+    },
+    // Ethereum Sepolia (Testnet) - disabled until NZIP is deployed
+    // 11155111: {
+    //   address: '0x0000000000000000000000000000000000000000',
+    //   network: 'Sepolia Testnet',
+    //   chainId: 11155111,
+    //   explorerUrl: 'https://sepolia.etherscan.io',
+    //   rpcUrls: []
+    // },
+    // Ethereum Mainnet (Production) - disabled until NZIP is deployed
+    // 1: {
+    //   address: '0x0000000000000000000000000000000000000000',
+    //   network: 'Ethereum Mainnet',
+    //   chainId: 1,
+    //   explorerUrl: 'https://etherscan.io',
+    //   rpcUrls: []
+    // }
+};
+// Contract ABI (same for all networks)
+exports.NZIP_CONTRACT_ABI = [
+    "function publicMintZipFile(string memory fileName, string memory merkleRootHash, 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 getZipFileInfo(uint256 tokenId) external view returns (tuple(string fileName, 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)",
+    "function isZipFileTokenized(string memory merkleRootHash, uint256 creationTimestamp) external view returns (bool exists, uint256 tokenId)",
+    "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 fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash, uint256 tokenizationTime, uint256 blockNumber)"
+];
+// Default configuration (Base Sepolia for development)
+exports.DEFAULT_NETWORK = 84532;
+exports.CURRENT_DEPLOYMENT = exports.CONTRACT_CONFIGS[exports.DEFAULT_NETWORK];
+// Helper functions
+const getContractConfig = (chainId) => {
+    return exports.CONTRACT_CONFIGS[chainId] || exports.CURRENT_DEPLOYMENT;
+};
+exports.getContractConfig = getContractConfig;
+const getSupportedNetworks = () => {
+    return Object.keys(exports.CONTRACT_CONFIGS).map(Number);
+};
+exports.getSupportedNetworks = getSupportedNetworks;
+const isNetworkSupported = (chainId) => {
+    return chainId in exports.CONTRACT_CONFIGS;
+};
+exports.isNetworkSupported = isNetworkSupported;

package/dist/blockchain/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export { ZipKitMinter, MintingOptions, MintingResult, DuplicateCheckResult, TokenInfo, WalletInfo, validatePrivateKey } from './ZipKitMinter';
+export { ZipKitVerifier, VerificationOptions, VerificationResult } from './ZipKitVerifier';
+export { TokenMetadata } from './types';
+export { NZIP_CONTRACT_ABI, CONTRACT_CONFIGS, CURRENT_DEPLOYMENT, DEFAULT_NETWORK, getContractConfig, getSupportedNetworks, isNetworkSupported } from './contracts';
+export { ZipKitWallet, WalletAnalyzer, NZipTokenDetails, WalletBasicInfo, TokenScanResult, CommonTokenConfig } from './ZipKitWallet';
+export { createTimestamp, deserializeOts, parseVerifyResult, createCertificateOts, upgradeOTS, createOtsMetadataEntry, bufferToArrayBuffer, getOtsEntry, getOtsBuffer, getMerkleRootSafe, verifyOts, verifyOtsZip, TimestampResult, TimestampInfo, DeserializeOtsResult, OtsVerifyResult } from './ZipKitOTS';

package/dist/blockchain/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyOtsZip = exports.verifyOts = exports.getMerkleRootSafe = exports.getOtsBuffer = exports.getOtsEntry = exports.bufferToArrayBuffer = exports.createOtsMetadataEntry = exports.upgradeOTS = exports.createCertificateOts = exports.parseVerifyResult = exports.deserializeOts = exports.createTimestamp = exports.WalletAnalyzer = exports.ZipKitWallet = exports.isNetworkSupported = exports.getSupportedNetworks = exports.getContractConfig = exports.DEFAULT_NETWORK = exports.CURRENT_DEPLOYMENT = exports.CONTRACT_CONFIGS = exports.NZIP_CONTRACT_ABI = exports.ZipKitVerifier = exports.validatePrivateKey = exports.ZipKitMinter = void 0;
+// Export all types
+__exportStar(require("./types"), exports);
+var ZipKitMinter_1 = require("./ZipKitMinter");
+Object.defineProperty(exports, "ZipKitMinter", { enumerable: true, get: function () { return ZipKitMinter_1.ZipKitMinter; } });
+Object.defineProperty(exports, "validatePrivateKey", { enumerable: true, get: function () { return ZipKitMinter_1.validatePrivateKey; } });
+var ZipKitVerifier_1 = require("./ZipKitVerifier");
+Object.defineProperty(exports, "ZipKitVerifier", { enumerable: true, get: function () { return ZipKitVerifier_1.ZipKitVerifier; } });
+var contracts_1 = require("./contracts");
+Object.defineProperty(exports, "NZIP_CONTRACT_ABI", { enumerable: true, get: function () { return contracts_1.NZIP_CONTRACT_ABI; } });
+Object.defineProperty(exports, "CONTRACT_CONFIGS", { enumerable: true, get: function () { return contracts_1.CONTRACT_CONFIGS; } });
+Object.defineProperty(exports, "CURRENT_DEPLOYMENT", { enumerable: true, get: function () { return contracts_1.CURRENT_DEPLOYMENT; } });
+Object.defineProperty(exports, "DEFAULT_NETWORK", { enumerable: true, get: function () { return contracts_1.DEFAULT_NETWORK; } });
+Object.defineProperty(exports, "getContractConfig", { enumerable: true, get: function () { return contracts_1.getContractConfig; } });
+Object.defineProperty(exports, "getSupportedNetworks", { enumerable: true, get: function () { return contracts_1.getSupportedNetworks; } });
+Object.defineProperty(exports, "isNetworkSupported", { enumerable: true, get: function () { return contracts_1.isNetworkSupported; } });
+// Export wallet management and analysis (combined under ZipKitWallet)
+var ZipKitWallet_1 = require("./ZipKitWallet");
+Object.defineProperty(exports, "ZipKitWallet", { enumerable: true, get: function () { return ZipKitWallet_1.ZipKitWallet; } });
+Object.defineProperty(exports, "WalletAnalyzer", { enumerable: true, get: function () { return ZipKitWallet_1.WalletAnalyzer; } });
+// Export OpenTimestamps utilities
+var ZipKitOTS_1 = require("./ZipKitOTS");
+Object.defineProperty(exports, "createTimestamp", { enumerable: true, get: function () { return ZipKitOTS_1.createTimestamp; } });
+Object.defineProperty(exports, "deserializeOts", { enumerable: true, get: function () { return ZipKitOTS_1.deserializeOts; } });
+Object.defineProperty(exports, "parseVerifyResult", { enumerable: true, get: function () { return ZipKitOTS_1.parseVerifyResult; } });
+Object.defineProperty(exports, "createCertificateOts", { enumerable: true, get: function () { return ZipKitOTS_1.createCertificateOts; } });
+Object.defineProperty(exports, "upgradeOTS", { enumerable: true, get: function () { return ZipKitOTS_1.upgradeOTS; } });
+Object.defineProperty(exports, "createOtsMetadataEntry", { enumerable: true, get: function () { return ZipKitOTS_1.createOtsMetadataEntry; } });
+Object.defineProperty(exports, "bufferToArrayBuffer", { enumerable: true, get: function () { return ZipKitOTS_1.bufferToArrayBuffer; } });
+Object.defineProperty(exports, "getOtsEntry", { enumerable: true, get: function () { return ZipKitOTS_1.getOtsEntry; } });
+Object.defineProperty(exports, "getOtsBuffer", { enumerable: true, get: function () { return ZipKitOTS_1.getOtsBuffer; } });
+Object.defineProperty(exports, "getMerkleRootSafe", { enumerable: true, get: function () { return ZipKitOTS_1.getMerkleRootSafe; } });
+Object.defineProperty(exports, "verifyOts", { enumerable: true, get: function () { return ZipKitOTS_1.verifyOts; } });
+Object.defineProperty(exports, "verifyOtsZip", { enumerable: true, get: function () { return ZipKitOTS_1.verifyOtsZip; } });