neozip-cli 0.70.0-alpha

package/dist/src/config/ConfigStore.js

@@ -0,0 +1,373 @@
+"use strict";
+/**
+ * ConfigStore - Configuration storage and retrieval manager for NeoZip
+ * Handles wallet.json file I/O, environment variable resolution, and config validation
+ * This is the data layer - handles all config storage/retrieval operations
+ */
+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.ConfigStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const contracts_1 = require('../../neozipkit-wrappers/blockchain/core/contracts');
+const DEFAULTS = {
+    network: 'base-sepolia',
+    rpcUrls: {
+        baseSepolia: 'https://sepolia.base.org',
+        baseMainnet: 'https://mainnet.base.org',
+    },
+    gas: {
+        multiplier: 1.0,
+        maxPriceGwei: 100,
+    },
+    debug: {
+        verbose: false,
+        enabled: false,
+    },
+};
+class ConfigStore {
+    /**
+     * Get the configuration directory path
+     */
+    static getConfigDir() {
+        return this.configDir;
+    }
+    /**
+     * Get the configuration file path
+     */
+    static getConfigPath() {
+        return this.configPath;
+    }
+    /**
+     * Check if wallet.json exists
+     */
+    static exists() {
+        return fs.existsSync(this.getConfigPath());
+    }
+    /**
+     * Load configuration from wallet.json
+     */
+    static load() {
+        if (!this.exists()) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(this.getConfigPath(), 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`⚠️  Failed to load wallet.json: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Save configuration to wallet.json
+     */
+    static save(config) {
+        try {
+            // Ensure config directory exists
+            const configDir = this.getConfigDir();
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+            }
+            // Write config file with restricted permissions
+            fs.writeFileSync(this.getConfigPath(), JSON.stringify(config, null, 2), { mode: 0o600 });
+            return true;
+        }
+        catch (error) {
+            console.error(`❌ Failed to save wallet.json: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Delete wallet.json configuration
+     */
+    static reset() {
+        try {
+            if (this.exists()) {
+                fs.unlinkSync(this.getConfigPath());
+            }
+            return true;
+        }
+        catch (error) {
+            console.error(`❌ Failed to delete wallet.json: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Get resolved configuration with precedence: CLI args > ENV vars > wallet.json > defaults
+     * @param cliWalletKey - Wallet key from CLI argument (highest priority)
+     */
+    static getConfig(cliWalletKey) {
+        const jsonConfig = this.load();
+        // Wallet key precedence: CLI > ENV > wallet.json
+        let walletKey = null;
+        if (cliWalletKey) {
+            walletKey = cliWalletKey;
+        }
+        else if (process.env.NEOZIP_WALLET_PASSKEY) {
+            walletKey = process.env.NEOZIP_WALLET_PASSKEY;
+        }
+        else if (jsonConfig?.wallet?.privateKey) {
+            walletKey = jsonConfig.wallet.privateKey;
+        }
+        // Network precedence: ENV > wallet.json > default
+        const network = process.env.NEOZIP_NETWORK ||
+            jsonConfig?.wallet?.network ||
+            DEFAULTS.network;
+        // RPC URLs precedence: ENV > wallet.json > default
+        const rpcUrls = {
+            baseSepolia: process.env.NEOZIP_BASE_SEPOLIA_RPC_URL ||
+                jsonConfig?.rpc?.baseSepolia ||
+                DEFAULTS.rpcUrls.baseSepolia,
+            baseMainnet: process.env.NEOZIP_BASE_MAINNET_RPC_URL ||
+                jsonConfig?.rpc?.baseMainnet ||
+                DEFAULTS.rpcUrls.baseMainnet,
+        };
+        // Gas settings precedence: ENV > wallet.json > default
+        const gas = {
+            multiplier: process.env.NEOZIP_GAS_MULTIPLIER ?
+                parseFloat(process.env.NEOZIP_GAS_MULTIPLIER) :
+                jsonConfig?.gas?.multiplier ||
+                    DEFAULTS.gas.multiplier,
+            maxPriceGwei: process.env.NEOZIP_MAX_GAS_PRICE ?
+                parseInt(process.env.NEOZIP_MAX_GAS_PRICE) :
+                jsonConfig?.gas?.maxPriceGwei ||
+                    DEFAULTS.gas.maxPriceGwei,
+        };
+        // Debug settings precedence: ENV > wallet.json > default
+        const debug = {
+            verbose: process.env.NEOZIP_VERBOSE === 'true' ||
+                jsonConfig?.debug?.verbose ||
+                DEFAULTS.debug.verbose,
+            enabled: process.env.NEOZIP_DEBUG === 'true' ||
+                jsonConfig?.debug?.enabled ||
+                DEFAULTS.debug.enabled,
+        };
+        return {
+            walletKey,
+            network,
+            rpcUrls,
+            gas,
+            debug,
+        };
+    }
+    /**
+     * Validate wallet private key format
+     */
+    static validatePrivateKey(key) {
+        // Must be 66 characters (0x + 64 hex chars) or 64 characters (without 0x)
+        const withPrefix = /^0x[0-9a-fA-F]{64}$/;
+        const withoutPrefix = /^[0-9a-fA-F]{64}$/;
+        return withPrefix.test(key) || withoutPrefix.test(key);
+    }
+    /**
+     * Validate network name (uses nameAliases from CONTRACT_CONFIGS)
+     */
+    static validateNetwork(network) {
+        return (0, contracts_1.getChainIdByName)(network) !== null;
+    }
+    /**
+     * Update a specific configuration value
+     */
+    static set(key, value) {
+        let config = this.load() || {
+            wallet: {},
+            rpc: {},
+            gas: {},
+            debug: {},
+        };
+        // Parse the key path (e.g., "wallet.privateKey", "gas.multiplier")
+        const parts = key.split('.');
+        switch (parts[0]) {
+            case 'wallet':
+                if (parts[1] === 'privateKey') {
+                    if (!this.validatePrivateKey(value)) {
+                        console.error('❌ Invalid private key format');
+                        return false;
+                    }
+                    config.wallet.privateKey = value.startsWith('0x') ? value : `0x${value}`;
+                }
+                else if (parts[1] === 'network') {
+                    if (!this.validateNetwork(value)) {
+                        const supportedNetworks = (0, contracts_1.getSupportedNetworkNames)();
+                        console.error(`❌ Invalid network: "${value}"`);
+                        console.error(`Supported networks: ${supportedNetworks.join(', ')}`);
+                        return false;
+                    }
+                    config.wallet.network = value;
+                }
+                break;
+            case 'rpc':
+                if (!config.rpc)
+                    config.rpc = {};
+                // Support both legacy keys and dynamic network keys
+                if (parts[1] === 'baseSepolia') {
+                    config.rpc.baseSepolia = value;
+                }
+                else if (parts[1] === 'baseMainnet') {
+                    config.rpc.baseMainnet = value;
+                }
+                else {
+                    // Allow dynamic network keys (e.g., "rpc.baseSepolia", "rpc.arbitrumSepolia")
+                    config.rpc[parts[1]] = value;
+                }
+                break;
+            case 'gas':
+                if (!config.gas)
+                    config.gas = {};
+                if (parts[1] === 'multiplier') {
+                    config.gas.multiplier = parseFloat(value);
+                }
+                else if (parts[1] === 'maxPriceGwei') {
+                    config.gas.maxPriceGwei = parseInt(value);
+                }
+                break;
+            case 'debug':
+                if (!config.debug)
+                    config.debug = {};
+                if (parts[1] === 'verbose') {
+                    config.debug.verbose = value === 'true';
+                }
+                else if (parts[1] === 'enabled') {
+                    config.debug.enabled = value === 'true';
+                }
+                break;
+            default:
+                console.error(`❌ Unknown configuration key: ${key}`);
+                return false;
+        }
+        return this.save(config);
+    }
+    /**
+     * Delete a specific configuration key
+     */
+    static delete(key) {
+        const config = this.load();
+        if (!config) {
+            console.error('❌ No configuration found');
+            return false;
+        }
+        // Parse the key path (e.g., "wallet.privateKey", "gas.multiplier")
+        const parts = key.split('.');
+        switch (parts[0]) {
+            case 'wallet':
+                if (parts[1] === 'privateKey') {
+                    delete config.wallet.privateKey;
+                }
+                else if (parts[1] === 'network') {
+                    delete config.wallet.network;
+                }
+                else {
+                    console.error(`❌ Unknown wallet key: ${parts[1]}`);
+                    return false;
+                }
+                break;
+            case 'rpc':
+                if (!config.rpc) {
+                    console.error('❌ No RPC configuration found');
+                    return false;
+                }
+                // Support both legacy keys and dynamic network keys
+                if (parts[1] === 'baseSepolia' || parts[1] === 'baseMainnet' || parts[1] in config.rpc) {
+                    delete config.rpc[parts[1]];
+                }
+                else {
+                    console.error(`❌ Unknown RPC key: ${parts[1]}`);
+                    return false;
+                }
+                break;
+            case 'gas':
+                if (!config.gas) {
+                    console.error('❌ No gas configuration found');
+                    return false;
+                }
+                if (parts[1] === 'multiplier') {
+                    delete config.gas.multiplier;
+                }
+                else if (parts[1] === 'maxPriceGwei') {
+                    delete config.gas.maxPriceGwei;
+                }
+                else {
+                    console.error(`❌ Unknown gas key: ${parts[1]}`);
+                    return false;
+                }
+                break;
+            case 'debug':
+                if (!config.debug) {
+                    console.error('❌ No debug configuration found');
+                    return false;
+                }
+                if (parts[1] === 'verbose') {
+                    delete config.debug.verbose;
+                }
+                else if (parts[1] === 'enabled') {
+                    delete config.debug.enabled;
+                }
+                else {
+                    console.error(`❌ Unknown debug key: ${parts[1]}`);
+                    return false;
+                }
+                break;
+            default:
+                console.error(`❌ Unknown configuration key: ${key}`);
+                return false;
+        }
+        return this.save(config);
+    }
+    /**
+     * Get a masked version of the config for display (hides sensitive data)
+     */
+    static getMaskedConfig() {
+        const config = this.getConfig();
+        const masked = {
+            wallet: {
+                privateKey: config.walletKey ?
+                    `${config.walletKey.substring(0, 6)}...${config.walletKey.substring(config.walletKey.length - 4)}` :
+                    '(not set)',
+                network: config.network,
+            },
+            rpc: config.rpcUrls,
+            gas: config.gas,
+            debug: config.debug,
+        };
+        return JSON.stringify(masked, null, 2);
+    }
+}
+exports.ConfigStore = ConfigStore;
+ConfigStore.configDir = path.join(os.homedir(), '.neozip');
+ConfigStore.configPath = path.join(ConfigStore.configDir, 'wallet.json');
+//# sourceMappingURL=ConfigStore.js.map