neozipkit 0.1.1 → 0.2.1

package/src/blockchain/ZipKitWallet.ts

@@ -0,0 +1,338 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { ethers } from 'ethers';
+import { WalletSetupResult, WalletInfo, NetworkConfig, NETWORKS, MintingOptions } from './types';
+
+export interface CommonTokenConfig { address: string; name: string; symbol: string; type: 'ERC20' | 'ERC721'; }
+export interface TokenInfo { address: string; name: string; symbol: string; balance: string; decimals?: number; type: 'ERC20' | 'ERC721' | 'NZIP'; }
+export interface WalletBasicInfo { ethBalance: string; transactionCount: number; networkName: string; chainId: bigint; latestBlock: number; }
+export interface TokenScanResult { foundTokens: number[]; searchMethod: 'recent-events' | 'iteration' | 'common-ids' | 'none'; }
+export interface NZipTokenDetails { tokenId: string; merkleRootHash: string; fileName: string; timestamp: number; tokenURI?: string; creator: string; creationTimestamp: number; tokenizationTime: number; ipfsHash?: string; }
+
+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)",
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function totalSupply() view returns (uint256)",
+  "function getTokensByMerkleRoot(string merkleRootHash) view returns (uint256[])",
+  "event ZipFileTokenized(uint256 indexed tokenId, address indexed creator, string fileName, string merkleRootHash, uint256 creationTimestamp, string ipfsHash)"
+];
+
+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)"
+];
+
+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)"
+];
+
+export class ZipKitWallet {
+  private wallet: ethers.Wallet | null = null;
+  private provider: ethers.JsonRpcProvider | null = null;
+
+  private async promptUser(question: string): Promise<string> {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise<string>((resolve) => {
+      rl.question(question, (answer: string) => { rl.close(); resolve(answer.trim()); });
+    });
+  }
+
+  private findExistingWallets(): string[] {
+    const walletFiles: string[] = [];
+    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;
+  }
+
+  private loadWalletFromFile(filePath: string): string | null {
+    try {
+      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) {
+      console.warn(`Could not read wallet file ${filePath}:`, error);
+      return null;
+    }
+  }
+
+  async setupWallet(options: MintingOptions): Promise<WalletSetupResult> {
+    try {
+      const networkConfig = NETWORKS[options.network] || NETWORKS['base-sepolia'];
+      let privateKey: string;
+      if ((options as any).wallet) {
+        const val = (options as any).wallet as string;
+        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.Wallet(privateKey);
+      console.log(`Using wallet: ${this.wallet.address}`);
+      const ok = await this.connectToNetwork(networkConfig, (options as any).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)}` };
+    }
+  }
+
+  private async createNewWallet(): Promise<string> {
+    console.log('Creating a new wallet...');
+    const newWallet = ethers.Wallet.createRandom();
+    const walletInfo: 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;
+  }
+
+  private async connectToNetwork(networkConfig: NetworkConfig, mintToken: boolean): Promise<boolean> {
+    try {
+      console.log(`Attempting to connect to ${networkConfig.name} network...`);
+      this.provider = new 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.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: unknown) {
+      const errorMessage = networkError instanceof Error ? networkError.message : String(networkError);
+      console.error(`Failed to connect to ${networkConfig.name} network: ${errorMessage}`);
+      this.provider = null;
+      return false;
+    }
+  }
+
+  getWallet(): ethers.Wallet | null { return this.wallet; }
+  getProvider(): ethers.JsonRpcProvider | null { return this.provider; }
+  isReady(): boolean { return this.wallet !== null; }
+  isOnline(): boolean { return this.provider !== null; }
+}
+
+export class WalletAnalyzer {
+  private provider: ethers.JsonRpcProvider;
+  constructor(provider: ethers.JsonRpcProvider) { this.provider = provider; }
+
+  async getWalletBasics(address: string): Promise<WalletBasicInfo> {
+    const balance = await this.provider.getBalance(address);
+    const ethBalance = 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: string, ownerAddress: string): Promise<TokenScanResult> {
+    const contract = new ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
+    let foundTokens: number[] = [];
+    let searchMethod: TokenScanResult['searchMethod'] = 'none';
+    try {
+      const latestBlock = await this.provider.getBlockNumber();
+      const startBlock = Math.max(0, latestBlock - 50000);
+      const filter = contract.filters.ZipFileTokenized(null, ownerAddress);
+      const events = await contract.queryFilter(filter, startBlock, 'latest');
+      for (const event of events) {
+        if ('args' in event && event.args && (event as any).args.tokenId) {
+          const tokenId = Number((event as any).args.tokenId);
+          if (!foundTokens.includes(tokenId)) foundTokens.push(tokenId);
+        }
+      }
+      if (foundTokens.length > 0) { return { foundTokens, searchMethod: 'recent-events' }; }
+    } catch {}
+    try {
+      const totalSupply = await contract.totalSupply();
+      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()) foundTokens.push(tokenId);
+        } catch {}
+      }
+      if (foundTokens.length > 0) return { foundTokens, searchMethod: 'iteration' };
+    } 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()) foundTokens.push(tokenId);
+      } catch {}
+    }
+    return { foundTokens, searchMethod: foundTokens.length > 0 ? 'common-ids' : 'none' };
+  }
+
+  async getNZipTokenDetails(contractAddress: string, tokenIds: number[]): Promise<NZipTokenDetails[]> {
+    const contract = new ethers.Contract(contractAddress, NZIP_CONTRACT_ABI, this.provider);
+    const tokenDetails: NZipTokenDetails[] = [];
+    for (const tokenId of tokenIds) {
+      try {
+        const zipInfo = await contract.getZipFileInfo(tokenId);
+        tokenDetails.push({
+          tokenId: tokenId.toString(),
+          merkleRootHash: zipInfo.merkleRootHash,
+          fileName: zipInfo.fileName,
+          timestamp: Number(zipInfo.creationTimestamp),
+          creator: zipInfo.creator,
+          creationTimestamp: Number(zipInfo.creationTimestamp),
+          tokenizationTime: Number(zipInfo.tokenizationTime),
+          ipfsHash: zipInfo.ipfsHash || undefined
+        });
+      } catch (error) {
+        console.error(`Error fetching details for token ${tokenId}:`, error);
+      }
+    }
+    return tokenDetails;
+  }
+
+  async getContractInfo(contractAddress: string): Promise<{name: string, symbol: string, totalSupply: string} | null> {
+    try {
+      const contract = new 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() };
+    } catch { return null; }
+  }
+
+  async checkERC20Tokens(ownerAddress: string, tokenConfigs: CommonTokenConfig[]): Promise<TokenInfo[]> {
+    const foundTokens: TokenInfo[] = [];
+    for (const tokenConfig of tokenConfigs.filter(t => t.type === 'ERC20')) {
+      try {
+        const contract = new ethers.Contract(tokenConfig.address, ERC20_ABI, this.provider);
+        const balance = await contract.balanceOf(ownerAddress);
+        if (balance > 0) {
+          let name = tokenConfig.name, symbol = tokenConfig.symbol, decimals = 18;
+          try { [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]); } catch {}
+          const formattedBalance = ethers.formatUnits(balance, decimals);
+          foundTokens.push({ address: tokenConfig.address, name, symbol, balance: formattedBalance, decimals, type: 'ERC20' });
+        }
+      } catch {}
+    }
+    return foundTokens;
+  }
+
+  async checkNFTCollections(ownerAddress: string, nftConfigs: CommonTokenConfig[]): Promise<TokenInfo[]> {
+    const foundNFTs: TokenInfo[] = [];
+    for (const nftConfig of nftConfigs) {
+      try {
+        const contract = new ethers.Contract(nftConfig.address, ERC721_ABI, this.provider);
+        const balance = await contract.balanceOf(ownerAddress);
+        if (balance > 0) {
+          let name = nftConfig.name, symbol = nftConfig.symbol;
+          try { [name, symbol] = await Promise.all([contract.name(), contract.symbol()]); } catch {}
+          foundNFTs.push({ address: nftConfig.address, name, symbol, balance: balance.toString(), type: 'ERC721' });
+        }
+      } catch {}
+    }
+    return foundNFTs;
+  }
+
+  static detectNZipContract(): string | undefined {
+    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) return deploymentInfo.address; } catch {}
+    }
+    return undefined;
+  }
+
+  static getCommonTokens(network: string): CommonTokenConfig[] {
+    const commonTokens: Record<string, CommonTokenConfig[]> = {
+      'base-sepolia': [
+        { address: '0x036CbD53842c5426634e7929541eC2318f3dCF7e', name: 'USD Coin', symbol: 'USDC', type: 'ERC20' },
+        { address: '0x4200000000000000000000000000000000000006', name: 'Wrapped Ether', symbol: 'WETH', type: 'ERC20' },
+        { address: '0xE4aB69C077896252FAFBD49EFD26B5D171A32410', name: 'Coinbase Wrapped Staked ETH', symbol: 'cbETH', type: 'ERC20' },
+      ],
+      'base': [
+        { address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', name: 'USD Coin', symbol: 'USDC', type: 'ERC20' },
+        { address: '0x4200000000000000000000000000000000000006', name: 'Wrapped Ether', symbol: 'WETH', type: 'ERC20' },
+        { address: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb', name: 'Dai Stablecoin', symbol: 'DAI', type: 'ERC20' },
+        { address: '0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22', name: 'Coinbase Wrapped Staked ETH', symbol: 'cbETH', type: 'ERC20' },
+        { address: '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA', name: 'USD Base Coin', symbol: 'USDbC', type: 'ERC20' },
+      ]
+    };
+    return commonTokens[network] || [];
+  }
+
+  static getCommonNFTs(network: string): CommonTokenConfig[] {
+    const commonNFTs: Record<string, CommonTokenConfig[]> = {
+      'base-sepolia': [ ],
+      'base': [
+        { address: '0x1234567890123456789012345678901234567890', name: 'Base Punks', symbol: 'BPUNK', type: 'ERC721' },
+        { address: '0x0987654321098765432109876543210987654321', name: 'Base Bears', symbol: 'BBEAR', type: 'ERC721' },
+      ]
+    };
+    return commonNFTs[network] || [];
+  }
+}
+
+

package/src/blockchain/contracts.ts

@@ -0,0 +1,88 @@
+// Contract addresses and configurations for different networks
+
+export interface ContractConfig {
+  address: string
+  network: string
+  chainId: number
+  explorerUrl: string
+  rpcUrls: string[]
+}
+
+// NZIP NFT Contract configurations by network
+export const CONTRACT_CONFIGS: Record<number, ContractConfig> = {
+  // 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)
+export const 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)
+export const DEFAULT_NETWORK = 84532
+export const CURRENT_DEPLOYMENT = CONTRACT_CONFIGS[DEFAULT_NETWORK]
+
+// Helper functions
+export const getContractConfig = (chainId: number): ContractConfig => {
+  return CONTRACT_CONFIGS[chainId] || CURRENT_DEPLOYMENT
+}
+
+export const getSupportedNetworks = (): number[] => {
+  return Object.keys(CONTRACT_CONFIGS).map(Number)
+}
+
+export const isNetworkSupported = (chainId: number): boolean => {
+  return chainId in CONTRACT_CONFIGS
+}

package/src/blockchain/index.ts

@@ -0,0 +1,61 @@
+// Export all types
+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 wallet management and analysis (combined under ZipKitWallet)
+export {
+  ZipKitWallet,
+  WalletAnalyzer,
+  NZipTokenDetails,
+  WalletBasicInfo,
+  TokenScanResult,
+  CommonTokenConfig
+} from './ZipKitWallet';
+
+// Export OpenTimestamps utilities
+export { 
+  createTimestamp,
+  deserializeOts,
+  parseVerifyResult,
+  createCertificateOts,
+  upgradeOTS,
+  createOtsMetadataEntry,
+  bufferToArrayBuffer,
+  getOtsEntry,
+  getOtsBuffer,
+  getMerkleRootSafe,
+  verifyOts,
+  verifyOtsZip,
+  // Export interfaces
+  TimestampResult,
+  TimestampInfo,
+  DeserializeOtsResult,
+  OtsVerifyResult
+} from './ZipKitOTS';

package/src/blockchain/types.ts

@@ -0,0 +1,91 @@
+import type { Wallet, JsonRpcProvider } from 'ethers';
+
+// Wallet and network types
+export interface WalletInfo {
+  address: string;
+  privateKey: string;
+  mnemonic: string;
+}
+
+export interface NetworkConfig {
+  name: string;
+  rpcUrl: string;
+  chainId: number;
+  explorerUrl: string;
+}
+
+export interface WalletSetupResult {
+  wallet: Wallet | null;
+  provider: JsonRpcProvider | null;
+  success: boolean;
+  message?: string;
+}
+
+export interface MintingResult {
+  success: boolean;
+  message: string;
+  tokenId?: string;
+  txHash?: string;
+  creationTimestamp?: number;
+}
+
+export interface MintingOptions {
+  wallet?: string;
+  network: string;
+  mintToken: boolean;
+}
+
+// Canonical token metadata used across minting, verification, and ZIP embedding
+export interface TokenMetadata {
+  // Core identifiers
+  tokenId: string;
+  contractAddress: string;
+  network: string;
+  merkleRoot: string;
+
+  // Optional chain info
+  networkChainId?: number;
+  transactionHash?: string;
+  blockNumber?: number;
+
+  // Names and timestamps (support both archiveName/fileName and mintedAt/mintDate)
+  fileName?: string;
+  archiveName?: string;
+  mintedAt?: string;
+  mintDate?: string;
+  creationTimestamp?: number;
+
+  // Optional content link
+  ipfsHash?: string;
+
+  // Versioning
+  version?: string;
+}
+
+// Network configuration
+export const NETWORKS: Record<string, NetworkConfig> = {
+  'base': {
+    name: 'Base Mainnet',
+    rpcUrl: 'https://mainnet.base.org',
+    chainId: 8453,
+    explorerUrl: 'https://basescan.org'
+  },
+  'base-sepolia': {
+    name: 'Base Sepolia',
+    rpcUrl: 'https://sepolia.base.org',
+    chainId: 84532,
+    explorerUrl: 'https://sepolia.basescan.org'
+  },
+  'base-goerli': {
+    name: 'Base Goerli',
+    rpcUrl: 'https://goerli.base.org',
+    chainId: 84531,
+    explorerUrl: 'https://goerli.basescan.org'
+  },
+  'localhost': {
+    name: 'Localhost',
+    rpcUrl: 'http://localhost:8545',
+    chainId: 31337,
+    explorerUrl: 'http://localhost:8545'
+  }
+};

package/src/browser/{TokenVerifierBrowser.ts → TokenVerifierBrowser.ts-remove}

@@ -7,7 +7,7 @@
 import ZipKitBrowser from './ZipKitBrowser';
 import { ZipEntry } from '../shared/ZipKit';
 import { TOKENIZED_METADATA } from '../shared/constants/Headers';
-import { NZIP_CONTRACT_ABI, CURRENT_DEPLOYMENT } from '../server/blockchain/constants';
+import { NZIP_CONTRACT_ABI, CURRENT_DEPLOYMENT } from '../blockchain/constants';
 
 // Token types (adapted for browser)
 export interface NZipTokenInfo {

package/src/browser-index.ts

@@ -12,9 +12,9 @@ export default ZipKit;
 
 // Browser-only exports
 export { default as ZipKitBrowser } from './browser/ZipKitBrowser';
-export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
-export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
-export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
+// export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
+// export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
+// export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
 
 // Shared component exports
 export { default as HashAccumulator } from './shared/components/HashAccumulator';

package/src/index.ts

@@ -2,6 +2,13 @@
 // NeoZipKit - Unified Package Exports
 // =============================================================================
 
+// Type and constant exports
+export * from './shared/types';
+export * from './shared/constants/Headers';
+export * from './shared/constants/Errors';
+export * from './shared/version';
+export { NEOZIPKIT_VERSION, NEOZIPKIT_RELEASE_DATE } from './shared/version';
+
 // Core shared exports
 import ZipKit from './shared/ZipKit';
 export { ZipEntry, Errors, CMP_METHOD, TIMESTAMP_METADATA, TIMESTAMP_SUBMITTED } from './shared/ZipKit';
@@ -12,33 +19,19 @@ export default ZipKit;
 
 // Browser-only exports
 export { default as ZipKitBrowser } from './browser/ZipKitBrowser';
-export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
-export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
-export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
 
 // Server-only exports (now included in main build)
-export { default as ZipKitServer } from './server/platform/server/ZipKitServer';
-export { verifyTimestamp, createTimestamp } from './server/platform/servercomponents/ZipKitOTS';
+export { default as ZipKitServer } from './server/ZipKitServer';
+export { createTimestamp } from './blockchain/ZipKitOTS';
 
 // Blockchain exports  
-export * from './server/blockchain';
-export { checkForTokenization as checkForTokenizationServer } from './server/blockchain/TokenVerifier';
-export { NFTMinter } from './server/blockchain/NFTMinter';
-export { WalletAnalyzer } from './server/blockchain/WalletAnalyzer';
-export { WalletManager } from './server/blockchain/WalletManager';
-export { ZipTokenProcessor } from './server/blockchain/ZipTokenProcessor';
+export * from './blockchain';
 
 // Shared component exports
 export { default as HashAccumulator } from './shared/components/HashAccumulator';
 export * from './shared/components/Util';
 export * from './shared/components/Support';
 
-// Type and constant exports
-export * from './shared/types';
-export * from './shared/constants/Headers';
-export * from './shared/constants/Errors';
-export * from './shared/version';
-
 // Platform-specific conditional exports
 export const PlatformUtils = {
   // Browser detection

package/src/server/README.md

@@ -0,0 +1,25 @@
+### Server APIs
+
+#### ZipKitServer
+- `loadZipFile(path)`
+  - Open or create a ZIP for writing; prepares entries for add/update operations.
+- `loadUnzipFile(path)`
+  - Open an existing ZIP for reading/extraction; throws on missing files.
+- `addFile(path, freshen?, update?)`
+  - Add a new entry or update an existing one (respects freshen/update flags).
+- `addFiles(paths[], freshen?, update?)`
+  - Batch add/update using `addFile` logic.
+- `createZip(path, options)`
+  - Write all staged entries to disk (no OpenTimestamps metadata).
+- `createZipOTS(path, options)`
+  - Write entries to disk and embed OpenTimestamps (OTS) metadata using the Merkle root.
+- `deleteFiles(paths[])`
+  - Delete entries by filename and rebuild central directory.
+- `upgradeOTS(zipPath, upgradedOts)`
+  - Replace OTS metadata in an existing archive with upgraded OTS bytes.
+
+Notes:
+- All read/write callbacks use Node Buffers. Ensure files exist on disk during `createZip*` flows.
+
+For OpenTimestamps utilities, see `src/blockchain/ZipKitOTS.ts`.
+