@neuraiproject/neurai-depin-terminal 1.0.0

package/src/ui/components/TopBar.js

@@ -0,0 +1,63 @@
+import blessed from 'blessed';
+import { UI, COLORS, ICONS } from '../../constants.js';
+import { parseRpcHost, formatTimestamp } from '../../utils.js';
+
+export class TopBar {
+  constructor(screen, config, myAddress) {
+    this.screen = screen;
+    this.config = config;
+    this.myAddress = myAddress;
+    this.totalMessages = 0;
+    this.encryptionType = 'N/A';
+    
+    this.component = blessed.box({
+      top: 0,
+      left: 0,
+      width: '100%',
+      height: UI.TOP_BAR_HEIGHT,
+      content: 'Loading...',
+      tags: true,
+      style: {
+        fg: COLORS.FG_WHITE,
+        bg: COLORS.BG_BLUE
+      }
+    });
+
+    this.screen.append(this.component);
+  }
+
+  update(status) {
+    const rpcUrl = parseRpcHost(this.config.rpc_url);
+    const connectedIndicator = status.connected ? 
+      `{${COLORS.CONNECTED}}${ICONS.CONNECTED}{/${COLORS.CONNECTED}}` : 
+      `{${COLORS.DISCONNECTED}}${ICONS.DISCONNECTED}{/${COLORS.DISCONNECTED}}`;
+    
+    const lastPollStr = status.lastPoll ? 
+      formatTimestamp(status.lastPoll, this.config.timezone) : 
+      '--:--:--';
+
+    // Format timezone display
+    let timezoneDisplay = this.config.timezone || 'UTC';
+    if (timezoneDisplay !== 'UTC') {
+       if (!timezoneDisplay.startsWith('+') && !timezoneDisplay.startsWith('-')) {
+           timezoneDisplay = `+${timezoneDisplay}`;
+       }
+       timezoneDisplay = `UTC${timezoneDisplay}`;
+    }
+
+    this.component.setContent(
+      `Neurai DePIN | ${connectedIndicator} RPC: ${rpcUrl} | Token: ${this.config.token} | Time: ${timezoneDisplay}\n` +
+      `Address: ${this.myAddress} | Total: ${this.totalMessages} | Encryption: ${this.encryptionType} | Last poll: ${lastPollStr}`
+    );
+
+    this.screen.render();
+  }
+
+  setTotalMessages(count) {
+    this.totalMessages = count;
+  }
+
+  setEncryptionType(type) {
+    this.encryptionType = type;
+  }
+}

package/src/utils.js

@@ -0,0 +1,309 @@
+/**
+ * Utility functions for Neurai DePIN Terminal
+ * @module utils
+ */
+
+import { KEY_CODES, TERMINAL } from './constants.js';
+
+/**
+ * Sleep for a specified duration
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Validate a URL string
+ * @param {string} url - URL to validate
+ * @returns {boolean} True if valid URL
+ */
+export function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate a timezone string (UTC or numeric offset)
+ * @param {string} timezone - Timezone to validate
+ * @returns {boolean} True if valid timezone
+ */
+export function isValidTimezone(timezone) {
+  if (timezone === 'UTC') return true;
+  // Allow numeric offsets like +1, -5, +5.5, -3.5, 2, -2
+  const offsetRegex = /^[+-]?\d+(\.\d+)?$/;
+  return offsetRegex.test(timezone);
+}
+
+/**
+ * Ensure RPC URL has the correct format
+ * @param {string} url - Base RPC URL
+ * @param {string} suffix - Suffix to append (default: '/rpc')
+ * @returns {string} Formatted RPC URL
+ */
+export function formatRpcUrl(url, suffix = '/rpc') {
+  if (!url.endsWith(suffix)) {
+    return url + suffix;
+  }
+  return url;
+}
+
+/**
+ * Truncate a string with ellipsis
+ * @param {string} str - String to truncate
+ * @param {number} length - Maximum length
+ * @param {string} [suffix='...'] - Suffix to append
+ * @returns {string} Truncated string
+ */
+export function truncate(str, length, suffix = '...') {
+  if (!str || str.length <= length) {
+    return str;
+  }
+  return str.slice(0, length) + suffix;
+}
+
+/**
+ * Format timestamp to locale time string
+ * @param {number|Date} timestamp - Unix timestamp in seconds or Date object
+ * @param {string} [timezone='UTC'] - Timezone offset (e.g., 'UTC', '+1', '-5')
+ * @returns {string} Formatted time string
+ */
+export function formatTimestamp(timestamp, timezone = 'UTC') {
+  const date = timestamp instanceof Date ? timestamp : new Date(timestamp * 1000);
+  
+  // Handle UTC explicitly
+  if (timezone === 'UTC') {
+    return date.toLocaleTimeString('en-US', { 
+      timeZone: 'UTC',
+      hour12: false,
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+  }
+
+  // Handle numeric offset
+  const offset = parseFloat(timezone);
+  if (!isNaN(offset)) {
+    // Create a new date shifted by the offset hours
+    // We use UTC for display to avoid local system timezone interference
+    const shiftedDate = new Date(date.getTime() + (offset * 60 * 60 * 1000));
+    return shiftedDate.toLocaleTimeString('en-US', { 
+      timeZone: 'UTC',
+      hour12: false,
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+  }
+
+  // Fallback to UTC
+  return date.toLocaleTimeString('en-US', { 
+    timeZone: 'UTC',
+    hour12: false,
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  });
+}
+
+/**
+ * Create a deduplication key from message hash and signature
+ * @param {string} hash - Message hash
+ * @param {string} signature - Message signature
+ * @returns {string} Deduplication key
+ */
+export function createMessageKey(hash, signature) {
+  return `${hash}|${signature}`;
+}
+
+/**
+ * Read password from stdin with character masking
+ * @param {string} prompt - Prompt to display
+ * @param {string} [maskChar='*'] - Character to display for each typed character
+ * @returns {Promise<string>} The entered password
+ */
+export function readPassword(prompt, maskChar = '*') {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    let password = '';
+
+    const onData = (char) => {
+      switch (char) {
+        case KEY_CODES.ENTER:
+        case KEY_CODES.CARRIAGE_RETURN:
+        case KEY_CODES.CTRL_D:
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.removeListener('data', onData);
+          process.stdout.write('\n');
+          resolve(password);
+          break;
+
+        case KEY_CODES.CTRL_C:
+          process.stdout.write('\n');
+          process.exit(0);
+          break;
+
+        case KEY_CODES.BACKSPACE:
+        case KEY_CODES.BACKSPACE_ALT:
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            process.stdout.write(TERMINAL.BACKSPACE);
+          }
+          break;
+
+        default:
+          password += char;
+          process.stdout.write(maskChar);
+          break;
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+/**
+ * Suppress all console output during a function execution
+ * @param {Function} fn - Function to execute with suppressed console
+ * @returns {Promise<*>} Result of the function
+ */
+export async function withSuppressedConsole(fn) {
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  const originalInfo = console.info;
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+
+  console.log = () => {};
+  console.warn = () => {};
+  console.error = () => {};
+  console.info = () => {};
+  process.stdout.write = () => {};
+  process.stderr.write = () => {};
+
+  try {
+    return await fn();
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+    console.info = originalInfo;
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+  }
+}
+
+/**
+ * Reset terminal to normal state
+ * Useful for cleanup on exit
+ */
+export function resetTerminal() {
+  if (process.stdout.isTTY) {
+    try {
+      process.stdout.write(TERMINAL.EXIT_ALT_SCREEN);
+      process.stdout.write(TERMINAL.SHOW_CURSOR);
+      process.stdout.write(TERMINAL.RESET_ATTRIBUTES);
+      process.stdout.write(TERMINAL.NEW_LINE);
+    } catch (err) {
+      // Ignore errors during terminal reset
+    }
+  }
+
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    } catch (err) {
+      // Ignore errors during stdin reset
+    }
+  }
+}
+
+/**
+ * Parse RPC host from URL for display
+ * @param {string} url - Full RPC URL
+ * @returns {string} Hostname:port
+ */
+export function parseRpcHost(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.host;
+  } catch {
+    return url;
+  }
+}
+
+/**
+ * Validate password meets requirements
+ * @param {string} password - Password to validate
+ * @param {number} minLength - Minimum length
+ * @param {number} maxLength - Maximum length
+ * @returns {{valid: boolean, error: string|null}} Validation result
+ */
+export function validatePassword(password, minLength, maxLength) {
+  if (!password || password.length < minLength) {
+    return {
+      valid: false,
+      error: `Password must be at least ${minLength} characters`
+    };
+  }
+
+  if (password.length > maxLength) {
+    return {
+      valid: false,
+      error: `Password must be at most ${maxLength} characters`
+    };
+  }
+
+  return { valid: true, error: null };
+}
+
+/**
+ * Check if a public key has been revealed
+ * @param {Object} pubkeyResponse - Response from getpubkey RPC call
+ * @returns {boolean} True if pubkey is revealed and valid
+ */
+export function isPubkeyRevealed(pubkeyResponse) {
+  return pubkeyResponse?.pubkey &&
+         pubkeyResponse?.revealed === 1 &&
+         pubkeyResponse.pubkey.trim().length > 0;
+}
+
+/**
+ * Normalize public key to lowercase hex
+ * @param {string} pubkey - Public key to normalize
+ * @returns {string} Normalized public key
+ */
+export function normalizePubkey(pubkey) {
+  return pubkey.trim().toLowerCase();
+}
+
+/**
+ * Check if server has privacy layer enabled
+ * @param {Object} msgInfo - Response from depingetmsginfo
+ * @returns {boolean} True if privacy layer is enabled
+ */
+export function hasPrivacyLayer(msgInfo) {
+  return msgInfo?.depinpoolpkey && msgInfo.depinpoolpkey !== '0';
+}
+
+/**
+ * Check if response indicates encrypted privacy layer
+ * @param {Object} response - RPC response
+ * @returns {boolean} True if response is encrypted
+ */
+export function isEncryptedResponse(response) {
+  return Boolean(response?.encrypted);
+}

package/src/wallet/WalletManager.js

@@ -0,0 +1,94 @@
+/**
+ * Wallet manager for Neurai DePIN Terminal
+ * Handles wallet initialization and key derivation
+ * @module WalletManager
+ */
+
+import NeuraiKey from '@neuraiproject/neurai-key';
+import secp256k1 from 'secp256k1';
+import {
+  ADDRESS,
+  ERROR_MESSAGES
+} from '../constants.js';
+import { WalletError } from '../errors.js';
+import { withSuppressedConsole } from '../utils.js';
+
+/**
+ * Manages wallet operations
+ */
+export class WalletManager {
+  /**
+   * Create a new WalletManager instance
+   * @param {Object} config - Configuration object
+   * @param {string} config.network - Network name (xna)
+   * @param {string} config.privateKey - WIF private key
+   */
+  constructor(config) {
+    this.config = config;
+    this.address = null;
+    this.publicKey = null;
+    this.privateKeyHex = null;
+  }
+
+  /**
+   * Derive address and public key from WIF private key
+   * Uses NeuraiKey to get address and secp256k1 to derive compressed public key
+   * @returns {Promise<void>}
+   * @throws {WalletError} If key derivation fails
+   */
+  async deriveKeysFromWif() {
+    try {
+      // Suppress NeuraiKey console output
+      const keyInfo = await withSuppressedConsole(() => {
+        return NeuraiKey.getAddressByWIF(this.config.network, this.config.privateKey);
+      });
+
+      this.address = keyInfo.address;
+      this.privateKeyHex = keyInfo.privateKey;
+
+      // Derive compressed public key from private key
+      const privateKeyBuffer = Buffer.from(keyInfo.privateKey, 'hex');
+      const publicKeyBuffer = secp256k1.publicKeyCreate(privateKeyBuffer, true);
+      this.publicKey = Buffer.from(publicKeyBuffer).toString('hex');
+    } catch (error) {
+      throw new WalletError(`${ERROR_MESSAGES.INVALID_WIF}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Initialize wallet: derive keys
+   * @returns {Promise<void>}
+   * @throws {WalletError} If key derivation fails
+   */
+  async initialize() {
+    // Derive keys from WIF (fatal if fails)
+    await this.deriveKeysFromWif();
+
+    console.log(`DePIN Address: ${this.address}`);
+    console.log(`Public Key: ${this.publicKey.slice(0, ADDRESS.PUBKEY_DISPLAY_LENGTH)}...`);
+  }
+
+  /**
+   * Get wallet address
+   * @returns {string} Neurai address
+   */
+  getAddress() {
+    return this.address;
+  }
+
+  /**
+   * Get public key
+   * @returns {string} Compressed public key in hex format
+   */
+  getPublicKey() {
+    return this.publicKey;
+  }
+
+  /**
+   * Get private key in hex format
+   * @returns {string} Private key in hex format
+   */
+  getPrivateKeyHex() {
+    return this.privateKeyHex;
+  }
+}