@neuraiproject/neurai-depin-terminal 1.0.0

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@neuraiproject/neurai-depin-terminal",
+  "version": "1.0.0",
+  "description": "Neurai DePIN terminal messaging client",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "bin": {
+    "neurai-depin-terminal": "dist/index.cjs"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "config.example.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "bundle": "esbuild src/index.js --bundle --platform=node --format=cjs --outfile=dist/index.cjs --minify --external:secp256k1 --alias:term.js=./src/lib/empty.js --alias:pty.js=./src/lib/empty.js --log-override:empty-import-meta=silent",
+    "prepublishOnly": "npm run bundle",
+    "build": "npm run bundle && NODE_NO_WARNINGS=1 pkg dist/index.cjs --targets node18-linux-x64,node18-macos-x64,node18-win-x64 --output bin/neurai-depin-terminal --compress GZip"
+  },
+  "pkg": {
+    "assets": [
+      "node_modules/@neuraiproject/neurai-depin-msg/dist/neurai-depin-msg.js"
+    ],
+    "scripts": [
+      "node_modules/blessed/lib/**/*.js",
+      "node_modules/blessed-contrib/lib/**/*.js"
+    ]
+  },
+  "keywords": [
+    "neurai",
+    "depin",
+    "messaging",
+    "terminal",
+    "cli"
+  ],
+  "author": "Neurai Community",
+  "license": "MIT",
+  "dependencies": {
+    "@neuraiproject/neurai-depin-msg": "^2.1.1",
+    "@neuraiproject/neurai-jswallet": "0.12.8",
+    "@neuraiproject/neurai-key": "^2.8.5",
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.11.0",
+    "chalk": "^5.3.0",
+    "readline": "^1.3.0",
+    "secp256k1": "^4.0.4"
+  },
+  "devDependencies": {
+    "esbuild": "^0.27.2",
+    "pkg": "^5.8.1"
+  }
+}

package/src/config/ConfigManager.js

@@ -0,0 +1,363 @@
+/**
+ * Configuration manager for Neurai DePIN Terminal
+ * Handles loading, creating, validating, and encrypting configuration
+ * @module ConfigManager
+ */
+
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import crypto from 'crypto';
+import {
+  CONFIG,
+  ENCRYPTION,
+  PASSWORD,
+  NETWORK,
+  POLLING,
+  ERROR_MESSAGES,
+  SUCCESS_MESSAGES
+} from '../constants.js';
+import { ConfigError, PasswordError, EncryptionError } from '../errors.js';
+import { readPassword, validatePassword, isValidUrl, isValidTimezone } from '../utils.js';
+
+/**
+ * Manages application configuration with encrypted private key storage
+ */
+export class ConfigManager {
+  /**
+   * Create a new ConfigManager instance
+   */
+  constructor() {
+    this.configPath = path.join(process.cwd(), CONFIG.FILE_NAME);
+    this.config = null;
+  }
+
+  /**
+   * Encrypt private key using AES-256-GCM
+   * @param {string} privateKey - Plain text private key in WIF format
+   * @param {string} password - Password for encryption
+   * @returns {string} Encrypted data in format: salt:iv:authTag:encrypted (hex)
+   * @throws {EncryptionError} If encryption fails
+   */
+  encryptPrivateKey(privateKey, password) {
+    try {
+      const salt = crypto.randomBytes(ENCRYPTION.SALT_LENGTH);
+      const key = crypto.scryptSync(
+        password,
+        salt,
+        ENCRYPTION.KEY_LENGTH,
+        {
+          N: ENCRYPTION.SCRYPT_COST,
+          r: ENCRYPTION.SCRYPT_BLOCK_SIZE,
+          p: ENCRYPTION.SCRYPT_PARALLELIZATION
+        }
+      );
+      const iv = crypto.randomBytes(ENCRYPTION.IV_LENGTH);
+      const cipher = crypto.createCipheriv(ENCRYPTION.ALGORITHM, key, iv);
+
+      let encrypted = cipher.update(privateKey, 'utf8', 'hex');
+      encrypted += cipher.final('hex');
+      const authTag = cipher.getAuthTag();
+
+      return `${salt.toString('hex')}:${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
+    } catch (error) {
+      throw new EncryptionError(`Failed to encrypt private key: ${error.message}`);
+    }
+  }
+
+  /**
+   * Decrypt private key using AES-256-GCM
+   * @param {string} encryptedData - Encrypted data in format: salt:iv:authTag:encrypted
+   * @param {string} password - Password for decryption
+   * @returns {string} Decrypted private key in WIF format
+   * @throws {EncryptionError} If decryption fails or password is incorrect
+   */
+  decryptPrivateKey(encryptedData, password) {
+    try {
+      const parts = encryptedData.split(':');
+      if (parts.length !== 4) {
+        throw new EncryptionError('Invalid encrypted data format');
+      }
+
+      const salt = Buffer.from(parts[0], 'hex');
+      const iv = Buffer.from(parts[1], 'hex');
+      const authTag = Buffer.from(parts[2], 'hex');
+      const encrypted = parts[3];
+
+      const key = crypto.scryptSync(
+        password,
+        salt,
+        ENCRYPTION.KEY_LENGTH,
+        {
+          N: ENCRYPTION.SCRYPT_COST,
+          r: ENCRYPTION.SCRYPT_BLOCK_SIZE,
+          p: ENCRYPTION.SCRYPT_PARALLELIZATION
+        }
+      );
+      const decipher = crypto.createDecipheriv(ENCRYPTION.ALGORITHM, key, iv);
+      decipher.setAuthTag(authTag);
+
+      let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+      decrypted += decipher.final('utf8');
+
+      return decrypted;
+    } catch (error) {
+      if (error instanceof EncryptionError) {
+        throw error;
+      }
+      throw new EncryptionError(ERROR_MESSAGES.INVALID_PASSWORD);
+    }
+  }
+
+  /**
+   * Prompt user for password with retry logic
+   * @param {number} [maxAttempts=3] - Maximum number of attempts
+   * @returns {Promise<string>} Decrypted private key
+   * @throws {PasswordError} If max attempts exceeded
+   */
+  async promptForDecryption(maxAttempts = PASSWORD.MAX_ATTEMPTS) {
+    console.log('\n🔐 Your private key is encrypted.');
+    let decrypted = false;
+    let attempts = 0;
+    let privateKey = null;
+
+    while (!decrypted && attempts < maxAttempts) {
+      attempts++;
+      const password = await readPassword('Enter password to decrypt private key: ');
+
+      try {
+        privateKey = this.decryptPrivateKey(this.config.privateKey, password);
+        decrypted = true;
+        console.log('✓ Private key decrypted successfully\n');
+      } catch (error) {
+        if (attempts < maxAttempts) {
+          console.log(`✗ Incorrect password. ${maxAttempts - attempts} attempts remaining.\n`);
+        } else {
+          throw new PasswordError(ERROR_MESSAGES.MAX_ATTEMPTS_REACHED);
+        }
+      }
+    }
+
+    return privateKey;
+  }
+
+  /**
+   * Prompt user to create and confirm a password
+   * @returns {Promise<string>} Validated password
+   */
+  async promptForPasswordCreation() {
+    console.log('\n🔐 To protect your private key, it will be encrypted with a password.');
+
+    while (true) {
+      const password = await readPassword(`Enter password (${PASSWORD.MIN_LENGTH}-${PASSWORD.MAX_LENGTH} characters): `);
+
+      const validation = validatePassword(password, PASSWORD.MIN_LENGTH, PASSWORD.MAX_LENGTH);
+      if (!validation.valid) {
+        console.log(`✗ ${validation.error}\n`);
+        continue;
+      }
+
+      const passwordConfirm = await readPassword('Confirm password: ');
+
+      if (password !== passwordConfirm) {
+        console.log(`✗ ${ERROR_MESSAGES.PASSWORDS_DONT_MATCH}\n`);
+        continue;
+      }
+
+      return password;
+    }
+  }
+
+  /**
+   * Prompt user for input using readline
+   * @param {readline.Interface} rl - Readline interface
+   * @param {string} prompt - Prompt message
+   * @returns {Promise<string>} User input
+   */
+  async promptInput(rl, prompt) {
+    return new Promise((resolve) => {
+      rl.question(prompt, resolve);
+    });
+  }
+
+  /**
+   * Load configuration from file or run wizard if not found
+   * @returns {Promise<Object>} Configuration object
+   * @throws {ConfigError} If config is invalid
+   */
+  async load() {
+    if (!fs.existsSync(this.configPath)) {
+      console.log('config.json not found. Let\'s create it.');
+      await this.runWizard();
+    }
+
+    try {
+      const configData = fs.readFileSync(this.configPath, 'utf-8');
+      this.config = JSON.parse(configData);
+    } catch (error) {
+      throw new ConfigError(`Failed to load config: ${error.message}`);
+    }
+
+    // Decrypt private key
+    this.config.privateKey = await this.promptForDecryption();
+
+    this.validate();
+    return this.config;
+  }
+
+  /**
+   * Run interactive configuration wizard
+   * @returns {Promise<void>}
+   */
+  async runWizard() {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log('\n================================');
+    console.log('Welcome to Neurai DePIN Client');
+    console.log('================================\n');
+
+    // Collect RPC server URL (required)
+    let rpc_url = '';
+    while (!rpc_url) {
+      rpc_url = await this.promptInput(rl, 'RPC Server URL (e.g., https://rpc-depin.neurai.org): ');
+      if (!rpc_url) {
+        console.log('Error: RPC server is required');
+      } else if (!isValidUrl(rpc_url)) {
+        console.log('Error: Invalid URL format');
+        rpc_url = '';
+      }
+    }
+
+    // Collect optional RPC credentials
+    const rpc_username = await this.promptInput(rl, 'RPC Username (optional, press Enter to skip): ') || '';
+    const rpc_password = await this.promptInput(rl, 'RPC Password (optional, press Enter to skip): ') || '';
+
+    // Collect token (required)
+    let token = '';
+    while (!token) {
+      token = await this.promptInput(rl, 'DePIN Token (asset name): ');
+      if (!token) {
+        console.log('Error: Token is required');
+      }
+    }
+
+    // Collect private key (required)
+    let privateKey = '';
+    while (!privateKey) {
+      privateKey = await this.promptInput(rl, 'Private Key (WIF format): ');
+      if (!privateKey) {
+        console.log('Error: Private key is required');
+      }
+    }
+
+    // Close readline before password input (uses raw mode)
+    rl.close();
+
+    // Get password and encrypt private key
+    const password = await this.promptForPasswordCreation();
+    const encryptedPrivateKey = this.encryptPrivateKey(privateKey, password);
+    console.log('✓ Private key encrypted successfully\n');
+
+    // Create new readline for remaining questions
+    const rl2 = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const pollIntervalStr = await this.promptInput(
+      rl2,
+      `Polling interval in ms [${POLLING.DEFAULT_INTERVAL}]: `
+    ) || String(POLLING.DEFAULT_INTERVAL);
+
+    // Collect timezone (optional, default UTC)
+    let timezone = '';
+    while (!timezone) {
+      const input = await this.promptInput(
+        rl2,
+        'Timezone offset (e.g., +1, -5, +5.5, UTC) [default: UTC]: '
+      );
+      
+      const candidate = input || 'UTC';
+      
+      if (isValidTimezone(candidate)) {
+        timezone = candidate;
+      } else {
+        console.log('Error: Invalid timezone. Please use numeric offset (e.g., +1, -5) or "UTC".');
+      }
+    }
+
+    rl2.close();
+
+    // Build configuration object
+    const config = {
+      rpc_url,
+      rpc_username,
+      rpc_password,
+      token,
+      privateKey: encryptedPrivateKey,
+      network: NETWORK.DEFAULT,
+      pollInterval: parseInt(pollIntervalStr, 10),
+      timezone
+    };
+
+    // Save to file
+    try {
+      fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+      console.log('Saving configuration to config.json...');
+      console.log('✓ Configuration saved\n');
+    } catch (error) {
+      throw new ConfigError(`Failed to save config: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate configuration object
+   * @throws {ConfigError} If validation fails
+   */
+  validate() {
+    if (!this.config) {
+      throw new ConfigError('Config not loaded');
+    }
+
+    if (!this.config.rpc_url) {
+      throw new ConfigError('rpc_url is required in config.json');
+    }
+
+    if (!isValidUrl(this.config.rpc_url)) {
+      throw new ConfigError(ERROR_MESSAGES.INVALID_RPC_URL);
+    }
+
+    if (!this.config.token) {
+      throw new ConfigError('token is required in config.json');
+    }
+
+    if (!this.config.privateKey) {
+      throw new ConfigError('privateKey is required in config.json');
+    }
+
+    // Force network to xna (mainnet only)
+    this.config.network = NETWORK.DEFAULT;
+
+    // Validate and adjust poll interval
+    if (!this.config.pollInterval || this.config.pollInterval < POLLING.MIN_INTERVAL) {
+      console.warn(`Warning: pollInterval too low, setting to ${POLLING.DEFAULT_INTERVAL}ms`);
+      this.config.pollInterval = POLLING.DEFAULT_INTERVAL;
+    }
+
+    if (this.config.pollInterval > POLLING.MAX_INTERVAL) {
+      console.warn(`Warning: pollInterval too high, setting to ${POLLING.MAX_INTERVAL}ms`);
+      this.config.pollInterval = POLLING.MAX_INTERVAL;
+    }
+  }
+
+  /**
+   * Get the loaded configuration
+   * @returns {Object} Configuration object
+   */
+  get() {
+    return this.config;
+  }
+}

package/src/constants.js

@@ -0,0 +1,208 @@
+/**
+ * Application-wide constants for Neurai DePIN Terminal
+ * @module constants
+ */
+
+// Network Configuration
+export const NETWORK = {
+  XNA: 'xna',
+  DEFAULT: 'xna'
+};
+
+// Encryption
+export const ENCRYPTION = {
+  ALGORITHM: 'aes-256-gcm',
+  SALT_LENGTH: 32,
+  IV_LENGTH: 16,
+  KEY_LENGTH: 32,
+  SCRYPT_COST: 16384,
+  SCRYPT_BLOCK_SIZE: 8,
+  SCRYPT_PARALLELIZATION: 1
+};
+
+// Password Validation
+export const PASSWORD = {
+  MIN_LENGTH: 4,
+  MAX_LENGTH: 30,
+  MAX_ATTEMPTS: 3
+};
+
+// Polling Configuration
+export const POLLING = {
+  DEFAULT_INTERVAL: 10000, // 10 seconds in milliseconds
+  MIN_INTERVAL: 1000,
+  MAX_INTERVAL: 60000
+};
+
+// RPC Configuration
+export const RPC = {
+  ENDPOINT_SUFFIX: '/rpc',
+  DEFAULT_URL: 'https://rpc-depin.neurai.org',
+  TIMEOUT: 30000,
+  DUMMY_MNEMONIC: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
+};
+
+// Message Deduplication
+export const MESSAGE = {
+  SEPARATOR: '|',
+  FORCE_POLL_DELAY: 2000
+};
+
+// Token Validation
+export const TOKEN = {
+  PREFIX: '&',
+  MIN_LENGTH: 2
+};
+
+// UI Layout
+export const UI = {
+  TOP_BAR_HEIGHT: 2,
+  INPUT_BOX_HEIGHT: 3,
+  STATUS_BAR_HEIGHT: 1,
+  MESSAGE_BOX_OFFSET: 6, // top bar + input + status
+  SCROLLBAR_CHAR: ' '
+};
+
+// UI Colors
+export const COLORS = {
+  CONNECTED: 'green-fg',
+  DISCONNECTED: 'red-fg',
+  MY_MESSAGE: 'cyan-fg',
+  OTHER_MESSAGE: 'green-fg',
+  ERROR: 'red-fg',
+  SUCCESS: 'green-fg',
+  INFO: 'yellow-fg',
+  BORDER: 'cyan',
+  BG_BLUE: 'blue',
+  BG_BLACK: 'black',
+  FG_WHITE: 'white'
+};
+
+// UI Status Icons
+export const ICONS = {
+  CONNECTED: '●',
+  DISCONNECTED: '●',
+  SUCCESS: '✓',
+  ERROR: '✗',
+  LOADING: '⟳'
+};
+
+// RPC Methods
+export const RPC_METHODS = {
+  GET_BLOCKCHAIN_INFO: 'getblockchaininfo',
+  DEPIN_RECEIVE_MSG: 'depinreceivemsg',
+  DEPIN_SUBMIT_MSG: 'depinsubmitmsg',
+  DEPIN_GET_MSG_INFO: 'depingetmsginfo',
+  LIST_ADDRESSES_BY_ASSET: 'listaddressesbyasset',
+  GET_PUBKEY: 'getpubkey'
+};
+
+// Terminal Control Sequences
+export const TERMINAL = {
+  EXIT_ALT_SCREEN: '\x1b[?1049l',
+  SHOW_CURSOR: '\x1b[?25h',
+  RESET_ATTRIBUTES: '\x1b[0m',
+  NEW_LINE: '\r\n',
+  BACKSPACE: '\b \b'
+};
+
+// Config File
+export const CONFIG = {
+  FILE_NAME: 'config.json',
+  EXAMPLE_FILE_NAME: 'config.example.json',
+  ENCRYPTED_KEY: 'privateKeyEncrypted',
+  PLAIN_KEY: 'privateKey'
+};
+
+// Special Key Codes
+export const KEY_CODES = {
+  ENTER: '\n',
+  CARRIAGE_RETURN: '\r',
+  CTRL_D: '\u0004',
+  CTRL_C: '\u0003',
+  BACKSPACE: '\u007f',
+  BACKSPACE_ALT: '\b'
+};
+
+// Error Messages
+export const ERROR_MESSAGES = {
+  CONFIG_NOT_FOUND: 'Configuration file not found',
+  INVALID_CONFIG: 'Invalid configuration',
+  INVALID_PASSWORD: 'Invalid password',
+  PASSWORD_TOO_SHORT: `Password must be at least ${PASSWORD.MIN_LENGTH} characters`,
+  PASSWORD_TOO_LONG: `Password must be at most ${PASSWORD.MAX_LENGTH} characters`,
+  PASSWORDS_DONT_MATCH: 'Passwords do not match',
+  MAX_ATTEMPTS_REACHED: `Maximum password attempts (${PASSWORD.MAX_ATTEMPTS}) reached`,
+  WALLET_INIT_FAILED: 'Failed to initialize wallet',
+  RPC_NOT_INITIALIZED: 'RPC client not initialized',
+  NO_TOKEN_HOLDERS: 'No token holders found',
+  NO_RECIPIENTS: 'No recipients found with revealed public key',
+  LIBRARY_LOAD_FAILED: 'Failed to load neuraiDepinMsg library',
+  INVALID_WIF: 'Invalid WIF private key format',
+  INVALID_TOKEN: `Token must start with "${TOKEN.PREFIX}"`,
+  INVALID_RPC_URL: 'Invalid RPC URL',
+  CONNECTION_ERROR: 'Connection error',
+  TOKEN_NOT_OWNED: 'This address does not own the configured token',
+  PUBKEY_NOT_REVEALED: 'Public key not revealed on blockchain'
+};
+
+// Success Messages
+export const SUCCESS_MESSAGES = {
+  CONFIG_LOADED: '✓ Configuration loaded',
+  LIBRARY_LOADED: '✓ DePIN library loaded',
+  RPC_CONNECTED: '✓ Connected to RPC server',
+  TOKEN_VERIFIED: '✓ Token ownership verified',
+  PUBKEY_VERIFIED: '✓ Public key revealed',
+  CONNECTED: 'Connected! Type your message and press Enter to send.'
+};
+
+// Info Messages
+export const INFO_MESSAGES = {
+  LOADING_CONFIG: 'Loading configuration...',
+  LOADING_LIBRARY: 'Loading DePIN library...',
+  INITIALIZING_WALLET: 'Initializing wallet...',
+  STARTING_UI: 'Starting terminal interface...',
+  PRESS_CTRL_C: 'Press Ctrl+C to exit.',
+  CONNECTING: 'Attempting to connect to DePIN server...',
+  RECONNECTING: 'Reconnecting, check server configuration',
+  SENDING: 'Sending message to all token holders...',
+  VERIFYING_TOKEN: 'Verifying token ownership...',
+  VERIFYING_PUBKEY: 'Verifying public key...'
+};
+
+// Warning Messages
+export const WARNING_MESSAGES = {
+  RPC_CONNECTION_FAILED: '⚠ Could not connect to RPC server. Will retry during polling.',
+  RPC_INIT_FAILED: '⚠ RPC client initialization failed. Will retry during polling.'
+};
+
+// Privacy Layer
+export const PRIVACY = {
+  NO_KEY_VALUE: '0',
+  DEFAULT_ENCRYPTION: 'N/A'
+};
+
+// Time Formats
+export const TIME = {
+  LOCALE_TIME: 'toLocaleTimeString',
+  PLACEHOLDER: '--:--:--'
+};
+
+// Blessed Keys
+export const BLESSED_KEYS = {
+  QUIT: ['C-c', 'escape'],
+  SEND: ['enter', 'C-s'],
+  SCROLL_UP: ['up'],
+  SCROLL_DOWN: ['down']
+};
+
+// Address Display
+export const ADDRESS = {
+  TRUNCATE_LENGTH: 10,
+  PUBKEY_DISPLAY_LENGTH: 20
+};
+
+// Hash Display
+export const HASH = {
+  DISPLAY_LENGTH: 16
+};