neozipkit 0.1.1

package/dist/server/blockchain/WalletManager.js

@@ -0,0 +1,294 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const ethers_1 = require("ethers");
+const types_1 = require("./types");
+class WalletManager {
+    constructor() {
+        this.wallet = null;
+        this.provider = null;
+    }
+    /**
+     * Prompts the user for input
+     */
+    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());
+            });
+        });
+    }
+    /**
+     * Looks for existing wallet files in the current directory and wallet subdirectory
+     */
+    findExistingWallets() {
+        const walletFiles = [];
+        const currentDir = process.cwd();
+        const walletDir = path.join(currentDir, 'wallet');
+        // Common wallet file names to look for
+        const walletFileNames = [
+            'neozip-wallet.json',
+            'wallet.json',
+            'private-key.txt',
+            'private.key'
+        ];
+        // Search in current directory
+        for (const fileName of walletFileNames) {
+            const filePath = path.join(currentDir, fileName);
+            if (fs.existsSync(filePath)) {
+                walletFiles.push(filePath);
+            }
+        }
+        // Search in wallet subdirectory
+        if (fs.existsSync(walletDir)) {
+            for (const fileName of walletFileNames) {
+                const filePath = path.join(walletDir, fileName);
+                if (fs.existsSync(filePath)) {
+                    walletFiles.push(filePath);
+                }
+            }
+        }
+        return walletFiles;
+    }
+    /**
+     * Loads wallet information from a file
+     */
+    loadWalletFromFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf8').trim();
+            // Try to parse as JSON first (for neozip-wallet.json format)
+            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 not JSON, treat as plain private key
+                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;
+        }
+    }
+    /**
+     * Sets up a Base wallet for token operations
+     */
+    async setupWallet(options) {
+        try {
+            const networkConfig = types_1.NETWORKS[options.network] || types_1.NETWORKS['base-sepolia'];
+            let privateKey;
+            // Check if wallet is explicitly provided via command line
+            if (options.wallet) {
+                if (fs.existsSync(options.wallet)) {
+                    // Read wallet from specified file
+                    const loadedKey = this.loadWalletFromFile(options.wallet);
+                    if (!loadedKey) {
+                        throw new Error(`Could not load valid private key from ${options.wallet}`);
+                    }
+                    privateKey = loadedKey;
+                }
+                else {
+                    // Use directly provided private key or mnemonic
+                    privateKey = options.wallet;
+                }
+            }
+            else {
+                // Look for existing wallet files
+                const existingWallets = this.findExistingWallets();
+                if (existingWallets.length > 0) {
+                    // Automatically use the first available wallet
+                    const selectedWallet = existingWallets[0];
+                    const relativePath = path.relative(process.cwd(), selectedWallet);
+                    console.log(`Using existing wallet: ${relativePath}`);
+                    const loadedKey = this.loadWalletFromFile(selectedWallet);
+                    if (!loadedKey) {
+                        throw new Error(`Could not load valid private key from ${selectedWallet}`);
+                    }
+                    privateKey = loadedKey;
+                }
+                else {
+                    // Automatically create new wallet
+                    console.log('No existing wallet found. Creating new wallet...');
+                    privateKey = await this.createNewWallet();
+                }
+            }
+            // Create wallet instance without provider first
+            this.wallet = new ethers_1.ethers.Wallet(privateKey);
+            console.log(`Using wallet: ${this.wallet.address}`);
+            // Try to connect to the network - FAIL if connection fails
+            const networkConnected = await this.connectToNetwork(networkConfig, options.mintToken);
+            if (!networkConnected) {
+                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)}`
+            };
+        }
+    }
+    /**
+     * Creates a new wallet and saves it to file
+     */
+    async createNewWallet() {
+        console.log('Creating a new wallet...');
+        const newWallet = ethers_1.ethers.Wallet.createRandom();
+        // Save the wallet info
+        const walletInfo = {
+            address: newWallet.address,
+            privateKey: newWallet.privateKey,
+            mnemonic: newWallet.mnemonic?.phrase || ""
+        };
+        // Ensure wallet directory exists
+        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;
+    }
+    /**
+     * Connects to the specified blockchain network
+     */
+    async connectToNetwork(networkConfig, mintToken) {
+        try {
+            console.log(`Attempting to connect to ${networkConfig.name} network...`);
+            this.provider = new ethers_1.ethers.JsonRpcProvider(networkConfig.rpcUrl);
+            // Set a timeout for network connection
+            let networkTimedOut = false;
+            const networkTimeout = setTimeout(() => {
+                networkTimedOut = true;
+                console.error("Network connection timeout");
+            }, 5000);
+            // Test the connection
+            const network = await Promise.race([
+                this.provider.getNetwork(),
+                new Promise((_, reject) => setTimeout(() => {
+                    if (networkTimedOut)
+                        reject(new Error("Network connection timeout"));
+                }, 5100))
+            ]);
+            clearTimeout(networkTimeout);
+            // Connect wallet to provider
+            if (this.wallet) {
+                this.wallet = this.wallet.connect(this.provider);
+                // Check wallet balance
+                const balance = await this.provider.getBalance(this.wallet.address);
+                const balanceEth = ethers_1.ethers.formatEther(balance);
+                console.log(`Wallet balance: ${balanceEth} ETH`);
+                // Check if balance is sufficient for minting
+                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;
+        }
+    }
+    /**
+     * Gets the current wallet instance
+     */
+    getWallet() {
+        return this.wallet;
+    }
+    /**
+     * Gets the current provider instance
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Checks if wallet is connected and ready for transactions
+     */
+    isReady() {
+        return this.wallet !== null;
+    }
+    /**
+     * Checks if provider is connected
+     */
+    isOnline() {
+        return this.provider !== null;
+    }
+}
+exports.WalletManager = WalletManager;

package/dist/server/blockchain/ZipMetadata.d.ts

@@ -0,0 +1,27 @@
+import { NZipTokenInfo, ContractInfo } from './types';
+export declare class ZipMetadata {
+    /**
+     * Creates the META-INF/NZIP.TOKEN content
+     */
+    static createTokenInfo(tokenId: string, transactionHash: string, contractInfo: ContractInfo, merkleRoot: string, fileName: string, network: string, blockNumber?: number, ipfsHash?: string, creationTimestamp?: number): NZipTokenInfo;
+    /**
+     * Creates the META-INF directory and NZIP.TOKEN file
+     */
+    static createTokenFile(tokenInfo: NZipTokenInfo): Promise<string>;
+    /**
+     * Reads token information from a ZIP file's META-INF/NZIP.TOKEN
+     */
+    static readTokenInfo(zipFilePath: string): NZipTokenInfo | null;
+    /**
+     * Validates token information structure
+     */
+    static validateTokenInfo(tokenInfo: any): tokenInfo is NZipTokenInfo;
+    /**
+     * Creates a human-readable summary of the token information
+     */
+    static createTokenSummary(tokenInfo: NZipTokenInfo): string;
+    /**
+     * No cleanup needed since we write to the current directory
+     */
+    static cleanupTokenFile(tokenFilePath: string): void;
+}

package/dist/server/blockchain/ZipMetadata.js

@@ -0,0 +1,131 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipMetadata = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+class ZipMetadata {
+    /**
+     * Creates the META-INF/NZIP.TOKEN content
+     */
+    static createTokenInfo(tokenId, transactionHash, contractInfo, merkleRoot, fileName, network, blockNumber, ipfsHash, creationTimestamp) {
+        const networkConfig = types_1.NETWORKS[network];
+        return {
+            version: "1.0",
+            tokenId,
+            contractAddress: contractInfo.address,
+            network: networkConfig.name,
+            networkChainId: networkConfig.chainId,
+            transactionHash,
+            merkleRoot,
+            fileName,
+            mintedAt: new Date().toISOString(),
+            creationTimestamp,
+            blockNumber,
+            ipfsHash
+        };
+    }
+    /**
+     * Creates the META-INF directory and NZIP.TOKEN file
+     */
+    static async createTokenFile(tokenInfo) {
+        const currentDir = process.cwd();
+        // Create META-INF directory in current directory
+        const metaInfDir = path.join(currentDir, 'META-INF');
+        if (!fs.existsSync(metaInfDir)) {
+            fs.mkdirSync(metaInfDir, { recursive: true });
+        }
+        // Create NZIP.TOKEN file
+        const tokenFilePath = path.join(metaInfDir, 'NZIP.TOKEN');
+        const tokenContent = JSON.stringify(tokenInfo, null, 2);
+        fs.writeFileSync(tokenFilePath, tokenContent);
+        console.log(`Created token metadata file: ${path.relative(currentDir, tokenFilePath)}`);
+        return tokenFilePath;
+    }
+    /**
+     * Reads token information from a ZIP file's META-INF/NZIP.TOKEN
+     */
+    static readTokenInfo(zipFilePath) {
+        // This would require extracting the META-INF/NZIP.TOKEN file from the ZIP
+        // For now, return null - this can be implemented when needed
+        return null;
+    }
+    /**
+     * Validates token information structure
+     */
+    static validateTokenInfo(tokenInfo) {
+        return (typeof tokenInfo === 'object' &&
+            typeof tokenInfo.version === 'string' &&
+            typeof tokenInfo.tokenId === 'string' &&
+            typeof tokenInfo.contractAddress === 'string' &&
+            typeof tokenInfo.network === 'string' &&
+            typeof tokenInfo.networkChainId === 'number' &&
+            typeof tokenInfo.transactionHash === 'string' &&
+            typeof tokenInfo.merkleRoot === 'string' &&
+            typeof tokenInfo.fileName === 'string' &&
+            typeof tokenInfo.mintedAt === 'string');
+    }
+    /**
+     * Creates a human-readable summary of the token information
+     */
+    static createTokenSummary(tokenInfo) {
+        return `
+═══════════════════════════════════════════════════════════════
+                    NeoZip Token Information
+═══════════════════════════════════════════════════════════════
+Token ID:       ${tokenInfo.tokenId}
+Contract:       ${tokenInfo.contractAddress}
+Network:        ${tokenInfo.network} (Chain ID: ${tokenInfo.networkChainId})
+Transaction:    ${tokenInfo.transactionHash}
+Block Number:   ${tokenInfo.blockNumber || 'Unknown'}
+Merkle Root:    ${tokenInfo.merkleRoot}
+File Name:      ${tokenInfo.fileName}
+Minted At:      ${tokenInfo.mintedAt}
+IPFS Hash:      ${tokenInfo.ipfsHash || 'Not uploaded'}
+Version:        ${tokenInfo.version}
+═══════════════════════════════════════════════════════════════
+    `.trim();
+    }
+    /**
+     * No cleanup needed since we write to the current directory
+     */
+    static cleanupTokenFile(tokenFilePath) {
+        // No cleanup needed since we're writing to the current directory
+        // The META-INF/NZIP.TOKEN file should remain in the current directory
+        console.log(`Token metadata file preserved at: ${path.relative(process.cwd(), tokenFilePath)}`);
+    }
+}
+exports.ZipMetadata = ZipMetadata;

package/dist/server/blockchain/ZipTokenProcessor.d.ts

@@ -0,0 +1,44 @@
+import { WalletManager } from './WalletManager';
+import { NFTMinter } from './NFTMinter';
+import { MintingOptions, ZipTokenData, WalletSetupResult, MintingResult, NZipTokenInfo } from './types';
+interface ProcessorState {
+    walletSetup?: WalletSetupResult;
+    mintingResult?: MintingResult;
+    tokenInfo?: NZipTokenInfo;
+    error?: string;
+}
+export declare class ZipTokenProcessor {
+    private walletManager;
+    private nftMinter;
+    private zipTokenData;
+    constructor(zipFile: string, merkleRoot: string, options: MintingOptions);
+    /**
+     * Processes the complete ZIP token workflow
+     */
+    processZipToken(options: MintingOptions): Promise<ProcessorState>;
+    /**
+     * Gets the ZIP token data
+     */
+    getZipTokenData(): ZipTokenData;
+    /**
+     * Gets the wallet manager instance
+     */
+    getWalletManager(): WalletManager;
+    /**
+     * Gets the NFT minter instance
+     */
+    getNFTMinter(): NFTMinter | null;
+    /**
+     * Loads contract deployment information
+     */
+    private loadContractInfo;
+    /**
+     * Creates token information object
+     */
+    private createTokenInfo;
+    /**
+     * Creates token information object from existing token
+     */
+    private createTokenInfoFromExisting;
+}
+export {};