neozipkit 0.1.1

package/dist/server/blockchain/WalletAnalyzer.js

@@ -0,0 +1,356 @@
+"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.WalletAnalyzer = void 0;
+const ethers_1 = require("ethers");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Contract ABI for NZIP tokens
+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)"
+];
+// 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;
+    }
+    /**
+     * Get basic wallet information (balance, transaction count, etc.)
+     */
+    async getWalletBasics(address) {
+        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
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to get wallet basics: ${error}`);
+        }
+    }
+    /**
+     * Scan for NZIP tokens owned by an address using multiple methods
+     */
+    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);
+            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.args.tokenId) {
+                    const tokenId = Number(event.args.tokenId);
+                    if (!foundTokens.includes(tokenId)) {
+                        foundTokens.push(tokenId);
+                    }
+                }
+            }
+            if (foundTokens.length > 0) {
+                searchMethod = 'recent-events';
+                return { foundTokens, searchMethod };
+            }
+        }
+        catch (eventError) {
+            // Continue to next method
+        }
+        // Method 2: Direct token ID checking (brute force for small supply)
+        try {
+            const totalSupply = await contract.totalSupply();
+            const maxCheck = Math.min(Number(totalSupply), 50); // Limit to 50 tokens max
+            for (let tokenId = 0; tokenId < maxCheck; tokenId++) {
+                try {
+                    const owner = await contract.ownerOf(tokenId);
+                    if (owner.toLowerCase() === ownerAddress.toLowerCase()) {
+                        foundTokens.push(tokenId);
+                    }
+                }
+                catch (ownerError) {
+                    // Token doesn't exist or other error, skip
+                }
+            }
+            if (foundTokens.length > 0) {
+                searchMethod = 'iteration';
+                return { foundTokens, searchMethod };
+            }
+        }
+        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
+        for (const tokenId of commonTokenIds) {
+            try {
+                const owner = await contract.ownerOf(tokenId);
+                if (owner.toLowerCase() === ownerAddress.toLowerCase()) {
+                    foundTokens.push(tokenId);
+                }
+            }
+            catch (ownerError) {
+                // Token doesn't exist, skip
+            }
+        }
+        if (foundTokens.length > 0) {
+            searchMethod = 'common-ids';
+        }
+        return { foundTokens, searchMethod };
+    }
+    /**
+     * 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 = [];
+        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;
+    }
+    /**
+     * 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()
+            };
+        }
+        catch (error) {
+            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')) {
+            try {
+                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;
+                    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
+                    }
+                    const formattedBalance = ethers_1.ethers.formatUnits(balance, decimals);
+                    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
+            }
+        }
+        return foundTokens;
+    }
+    /**
+     * Check NFT collection balances
+     */
+    async checkNFTCollections(ownerAddress, nftConfigs) {
+        const foundNFTs = [];
+        for (const nftConfig of nftConfigs) {
+            try {
+                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;
+                    try {
+                        [name, symbol] = await Promise.all([
+                            contract.name(),
+                            contract.symbol()
+                        ]);
+                    }
+                    catch (metadataError) {
+                        name = nftConfig.name;
+                        symbol = nftConfig.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 (error) {
+                // Contract might not exist or might not be ERC-721, continue silently
+            }
+        }
+        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) {
+                    return deploymentInfo.address;
+                }
+            }
+            catch (error) {
+                // Could not read deployment file
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get common token configurations for a network
+     */
+    static getCommonTokens(network) {
+        const commonTokens = {
+            '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] || [];
+    }
+    /**
+     * Get common NFT configurations for a network
+     */
+    static getCommonNFTs(network) {
+        const commonNFTs = {
+            'base-sepolia': [
+            // Add known testnet NFTs here when they become available
+            ],
+            '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' },
+            ]
+        };
+        return commonNFTs[network] || [];
+    }
+}
+exports.WalletAnalyzer = WalletAnalyzer;

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

@@ -0,0 +1,39 @@
+import { WalletBasicInfo, NZipTokenDetails, TokenInfo, TokenScanResult } from './WalletAnalyzer';
+export declare class WalletFormatter {
+    /**
+     * Display basic wallet information
+     */
+    static displayWalletBasics(walletInfo: WalletBasicInfo): void;
+    /**
+     * Display contract information
+     */
+    static displayContractInfo(contractInfo: {
+        name: string;
+        symbol: string;
+        totalSupply: string;
+    } | null, isLegacy?: boolean): void;
+    /**
+     * Display token scan progress
+     */
+    static displayTokenScanProgress(scanResult: TokenScanResult): void;
+    /**
+     * Display detailed NZIP token information
+     */
+    static displayNZipTokenDetails(tokenDetails: NZipTokenDetails[], scanResult: TokenScanResult, contractAddress: string): void;
+    /**
+     * Display ERC-20 token information
+     */
+    static displayERC20Tokens(tokens: TokenInfo[]): void;
+    /**
+     * Display NFT collection information
+     */
+    static displayNFTCollections(nfts: TokenInfo[]): void;
+    /**
+     * Display token scan summary
+     */
+    static displayTokenScanSummary(erc20Count: number, totalScanned: number): void;
+    /**
+     * Display error messages for contract connection issues
+     */
+    static displayContractError(error: any, contractAddress: string): void;
+}

package/dist/server/blockchain/WalletFormatter.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletFormatter = void 0;
+class WalletFormatter {
+    /**
+     * Display basic wallet information
+     */
+    static displayWalletBasics(walletInfo) {
+        console.log('\n💰 Basic Wallet Information');
+        console.log('─'.repeat(50));
+        console.log(`ETH Balance:                                    ${walletInfo.ethBalance} ETH`);
+        console.log(`Transaction Count:                              ${walletInfo.transactionCount}`);
+        console.log(`Network Name:                                   ${walletInfo.networkName}`);
+        console.log(`Chain ID:                                       ${walletInfo.chainId}`);
+        console.log(`Latest Block:                                   ${walletInfo.latestBlock}`);
+    }
+    /**
+     * Display contract information
+     */
+    static displayContractInfo(contractInfo, isLegacy = false) {
+        if (contractInfo) {
+            console.log(`Contract Name:                                  ${contractInfo.name}`);
+            console.log(`Contract Symbol:                                ${contractInfo.symbol}`);
+            console.log(`Total Supply:                                   ${contractInfo.totalSupply}`);
+        }
+        else {
+            console.log('Contract Info:                                  Unable to fetch');
+        }
+    }
+    /**
+     * Display token scan progress
+     */
+    static displayTokenScanProgress(scanResult) {
+        console.log('Searching for tokens owned by this address...');
+        if (scanResult.searchMethod === 'recent-events') {
+            console.log('   🔍 Trying recent events (last 50k blocks)...');
+            console.log(`   ✅ Found ${scanResult.foundTokens.length} tokens from recent events`);
+        }
+        else if (scanResult.searchMethod === 'iteration') {
+            console.log('   🔍 Trying recent events (last 50k blocks)...');
+            console.log('   ❌ Recent events failed, trying alternative methods...');
+            console.log('   🔍 Checking token ownership by iteration...');
+            console.log(`   ✅ Found ${scanResult.foundTokens.length} tokens by iteration`);
+        }
+        else if (scanResult.searchMethod === 'common-ids') {
+            console.log('   🔍 Trying recent events (last 50k blocks)...');
+            console.log('   ❌ Recent events failed, trying alternative methods...');
+            console.log('   🔍 Checking token ownership by iteration...');
+            console.log('   ⚠️  No tokens found by iteration, checking common IDs...');
+            console.log('   🔍 Checking common token IDs (0-19)...');
+            console.log(`   ✅ Found ${scanResult.foundTokens.length} tokens from common IDs`);
+        }
+        else {
+            console.log('   🔍 Trying recent events (last 50k blocks)...');
+            console.log('   ❌ Recent events failed, trying alternative methods...');
+            console.log('   🔍 Checking token ownership by iteration...');
+            console.log('   ⚠️  No tokens found by iteration, checking common IDs...');
+            console.log('   🔍 Checking common token IDs (0-19)...');
+        }
+    }
+    /**
+     * Display detailed NZIP token information
+     */
+    static displayNZipTokenDetails(tokenDetails, scanResult, contractAddress) {
+        if (tokenDetails.length > 0) {
+            console.log(`\n✅ Found ${tokenDetails.length} NZIP token(s) using ${scanResult.searchMethod}:`);
+            console.log('📋 Your NZIP Token Details:');
+            console.log('═'.repeat(80));
+            for (const token of tokenDetails.sort((a, b) => parseInt(a.tokenId) - parseInt(b.tokenId))) {
+                console.log(`\n🎯 Token ID ${token.tokenId}:`);
+                console.log(`   File Name:                                   ${token.fileName}`);
+                console.log(`   Merkle Root:                                 ${token.merkleRootHash}`);
+                // Convert timestamps to dates
+                const creationDate = new Date(token.creationTimestamp * 1000);
+                const tokenizationDate = new Date(token.tokenizationTime * 1000);
+                // Format dates in a more readable format
+                const formatOptions = {
+                    year: 'numeric',
+                    month: 'short',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    timeZoneName: 'short'
+                };
+                console.log(`   Created:                                     ${creationDate.toLocaleDateString('en-US', formatOptions)}`);
+                console.log(`   Tokenized:                                   ${tokenizationDate.toLocaleDateString('en-US', formatOptions)}`);
+                // Show time difference between creation and tokenization
+                const timeDiffSeconds = token.tokenizationTime - token.creationTimestamp;
+                if (timeDiffSeconds > 0) {
+                    if (timeDiffSeconds < 60) {
+                        console.log(`   Tokenization Delay:                          ${timeDiffSeconds} seconds`);
+                    }
+                    else if (timeDiffSeconds < 3600) {
+                        console.log(`   Tokenization Delay:                          ${Math.round(timeDiffSeconds / 60)} minutes`);
+                    }
+                    else {
+                        console.log(`   Tokenization Delay:                          ${Math.round(timeDiffSeconds / 3600)} hours`);
+                    }
+                }
+                if (token.ipfsHash && token.ipfsHash !== '') {
+                    console.log(`   IPFS Hash:                                   ${token.ipfsHash}`);
+                }
+                console.log(`   Creator:                                     ${token.creator}`);
+                // Calculate age since creation (using current time)
+                const now = Date.now();
+                const ageMs = now - (token.creationTimestamp * 1000);
+                const ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+                const ageHours = Math.floor((ageMs % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+                const ageMinutes = Math.floor((ageMs % (1000 * 60 * 60)) / (1000 * 60));
+                if (ageDays > 0) {
+                    console.log(`   Age:                                         ${ageDays} days, ${ageHours} hours`);
+                }
+                else if (ageHours > 0) {
+                    console.log(`   Age:                                         ${ageHours} hours, ${ageMinutes} minutes`);
+                }
+                else {
+                    console.log(`   Age:                                         ${ageMinutes} minutes`);
+                }
+            }
+        }
+        else {
+            console.log('\n❌ No NZIP tokens found for this address');
+            console.log('\n💡 This could mean:');
+            console.log('   • You don\'t own any NZIP tokens on this network');
+            console.log('   • The tokens are on a different contract or network');
+            console.log('   • There are temporary RPC connectivity issues');
+            console.log('\n🔧 Try these troubleshooting steps:');
+            console.log('   • Verify you\'re on the correct network (--network flag)');
+            console.log('   • Check if you have tokens on a different contract (--contract flag)');
+            console.log('   • Try again in a few minutes if RPC is experiencing issues');
+            console.log(`   • Verify the contract address: ${contractAddress}`);
+        }
+    }
+    /**
+     * Display ERC-20 token information
+     */
+    static displayERC20Tokens(tokens) {
+        if (tokens.length > 0) {
+            console.log(`\n💰 ERC-20 Token Balances:`);
+            for (const token of tokens) {
+                console.log(`\n   💎 ${token.symbol} (${token.name}):`);
+                console.log(`      Contract:                                 ${token.address}`);
+                console.log(`      Balance:                                  ${token.balance} ${token.symbol}`);
+                console.log(`      Decimals:                                 ${token.decimals}`);
+                // Add USD value estimation for major stablecoins
+                if (['USDC', 'USDT', 'DAI', 'USDbC'].includes(token.symbol)) {
+                    console.log(`      Est. USD Value:                           ~$${token.balance}`);
+                }
+            }
+        }
+    }
+    /**
+     * Display NFT collection information
+     */
+    static displayNFTCollections(nfts) {
+        console.log(`\n🖼️  Other NFT Collections:`);
+        if (nfts.length > 0) {
+            for (const nft of nfts) {
+                console.log(`\n   🖼️  ${nft.symbol} (${nft.name}):`);
+                console.log(`      Contract:                                 ${nft.address}`);
+                console.log(`      NFTs Owned:                               ${nft.balance}`);
+            }
+        }
+        else {
+            console.log(`   No other NFT collections found`);
+        }
+    }
+    /**
+     * Display token scan summary
+     */
+    static displayTokenScanSummary(erc20Count, totalScanned) {
+        console.log(`\n📊 Token Scan Summary:`);
+        console.log(`   ERC-20 Tokens Found:                          ${erc20Count}`);
+        console.log(`   Total Tokens Scanned:                         ${totalScanned}`);
+        if (erc20Count === 0) {
+            console.log(`\n💡 No tokens found. This could mean:`);
+            console.log(`   • This is a new wallet with no token activity`);
+            console.log(`   • Tokens are on a different network`);
+            console.log(`   • You have tokens not in our common token list`);
+            console.log(`   • There are temporary RPC connectivity issues`);
+        }
+    }
+    /**
+     * Display error messages for contract connection issues
+     */
+    static displayContractError(error, contractAddress) {
+        console.error('❌ Error connecting to NZIP contract:', error);
+        console.log('\n🔧 Troubleshooting suggestions:');
+        console.log('   • Check if the contract address is correct');
+        console.log('   • Verify you\'re on the right network');
+        console.log('   • Try again later if RPC is experiencing issues');
+        console.log('   • Use --contract flag to specify a different contract address');
+    }
+}
+exports.WalletFormatter = WalletFormatter;

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

@@ -0,0 +1,46 @@
+import { ethers } from 'ethers';
+import { WalletSetupResult, MintingOptions } from './types';
+export declare class WalletManager {
+    private wallet;
+    private provider;
+    /**
+     * Prompts the user for input
+     */
+    private promptUser;
+    /**
+     * Looks for existing wallet files in the current directory and wallet subdirectory
+     */
+    private findExistingWallets;
+    /**
+     * Loads wallet information from a file
+     */
+    private loadWalletFromFile;
+    /**
+     * Sets up a Base wallet for token operations
+     */
+    setupWallet(options: MintingOptions): Promise<WalletSetupResult>;
+    /**
+     * Creates a new wallet and saves it to file
+     */
+    private createNewWallet;
+    /**
+     * Connects to the specified blockchain network
+     */
+    private connectToNetwork;
+    /**
+     * Gets the current wallet instance
+     */
+    getWallet(): ethers.Wallet | null;
+    /**
+     * Gets the current provider instance
+     */
+    getProvider(): ethers.JsonRpcProvider | null;
+    /**
+     * Checks if wallet is connected and ready for transactions
+     */
+    isReady(): boolean;
+    /**
+     * Checks if provider is connected
+     */
+    isOnline(): boolean;
+}