@neuraiproject/neurai-depin-terminal 1.0.0

package/src/services/RpcService.js

@@ -0,0 +1,200 @@
+/**
+ * RPC Service for Neurai DePIN Terminal
+ * Handles RPC connection, initialization, and method calls
+ * @module RpcService
+ */
+
+import neuraiJsWallet from '@neuraiproject/neurai-jswallet';
+import {
+  RPC,
+  RPC_METHODS,
+  WARNING_MESSAGES,
+  SUCCESS_MESSAGES,
+  ERROR_MESSAGES
+} from '../constants.js';
+import { RpcError } from '../errors.js';
+import { formatRpcUrl } from '../utils.js';
+
+const { Wallet } = neuraiJsWallet;
+
+/**
+ * Manages RPC connectivity and method calls
+ */
+export class RpcService {
+  /**
+   * Create a new RpcService instance
+   * @param {Object} config - Configuration object
+   * @param {string} config.network - Network name (xna)
+   * @param {string} config.rpc_url - RPC server URL
+   * @param {string} [config.rpc_username] - Optional RPC username
+   * @param {string} [config.rpc_password] - Optional RPC password
+   */
+  constructor(config) {
+    this.config = config;
+    this.wallet = null;
+    this.connected = false;
+  }
+
+  /**
+   * Initialize RPC wallet client
+   * Creates a wallet instance for RPC access
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    const rpcUrl = formatRpcUrl(this.config.rpc_url, RPC.ENDPOINT_SUFFIX);
+
+    try {
+      this.wallet = new Wallet();
+      await this.wallet.init({
+        mnemonic: RPC.DUMMY_MNEMONIC,
+        network: this.config.network,
+        rpc_url: rpcUrl,
+        rpc_username: this.config.rpc_username || undefined,
+        rpc_password: this.config.rpc_password || undefined,
+        offlineMode: false,
+        minAmountOfAddresses: 1
+      });
+
+      // Test connection
+      await this.testConnection();
+    } catch (error) {
+      this.connected = false;
+      this.wallet = null;
+      console.warn(WARNING_MESSAGES.RPC_INIT_FAILED);
+      console.warn(`   Error: ${error.message || 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Test RPC connection by calling getblockchaininfo
+   * @param {boolean} [silent=false] - If true, suppress console output
+   * @returns {Promise<boolean>} True if connected, false otherwise
+   */
+  async testConnection(silent = false) {
+    try {
+      await this.wallet.rpc(RPC_METHODS.GET_BLOCKCHAIN_INFO, []);
+      this.connected = true;
+      if (!silent) console.log(SUCCESS_MESSAGES.RPC_CONNECTED);
+      return true;
+    } catch (error) {
+      this.connected = false;
+      if (!silent) console.warn(WARNING_MESSAGES.RPC_CONNECTION_FAILED);
+      return false;
+    }
+  }
+
+  /**
+   * Execute an RPC method
+   * @param {string} method - RPC method name
+   * @param {Array} [params=[]] - RPC parameters
+   * @returns {Promise<any>} RPC result
+   * @throws {RpcError} If RPC call fails or not initialized
+   */
+  async call(method, params = []) {
+    if (!this.wallet) {
+      throw new RpcError(ERROR_MESSAGES.RPC_NOT_INITIALIZED);
+    }
+    try {
+      const result = await this.wallet.rpc(method, params);
+      this.connected = true;
+      return result;
+    } catch (error) {
+      this.connected = false;
+      throw new RpcError(error.message);
+    }
+  }
+
+  /**
+   * Verify if an address holds a specific token
+   * @param {string} address - Address to check
+   * @param {string} token - Token name
+   * @returns {Promise<boolean>} True if address holds the token
+   */
+  async verifyTokenOwnership(address, token) {
+    try {
+      const result = await this.call(RPC_METHODS.LIST_ADDRESSES_BY_ASSET, [token]);
+      // Result is an object where keys are addresses and values are balances
+      return Object.prototype.hasOwnProperty.call(result, address) && result[address] > 0;
+    } catch (error) {
+      console.warn(`Failed to verify token ownership: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check if the public key for an address is revealed on the blockchain
+   * @param {string} address - Address to check
+   * @returns {Promise<boolean>} True if public key is revealed
+   */
+  async checkPubKeyRevealed(address) {
+    try {
+      const result = await this.call(RPC_METHODS.GET_PUBKEY, [address]);
+      return result && (result.revealed === 1 || result.revealed === true);
+    } catch (error) {
+      console.warn(`Failed to check pubkey: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check if currently connected to RPC server
+   * @returns {boolean} Connection status
+   */
+  isConnected() {
+    return this.connected;
+  }
+
+  /**
+   * Attempt to reconnect to RPC server
+   * Tries to reinitialize the wallet if not connected
+   * @param {boolean} [silent=true] - If true, suppress console output
+   * @returns {Promise<boolean>} True if reconnection successful, false otherwise
+   */
+  async attemptReconnect(silent = true) {
+    // If already connected, no need to reconnect
+    if (this.connected && this.wallet) {
+      return true;
+    }
+
+    // If wallet exists, just test the connection
+    if (this.wallet) {
+      try {
+        await this.wallet.rpc(RPC_METHODS.GET_BLOCKCHAIN_INFO, []);
+        this.connected = true;
+        return true;
+      } catch (error) {
+        this.connected = false;
+      }
+    }
+
+    // Wallet doesn't exist or check failed, need to reinitialize RPC client
+    try {
+      const rpcUrl = formatRpcUrl(this.config.rpc_url, RPC.ENDPOINT_SUFFIX);
+
+      this.wallet = new Wallet();
+      await this.wallet.init({
+        mnemonic: RPC.DUMMY_MNEMONIC,
+        network: this.config.network,
+        rpc_url: rpcUrl,
+        rpc_username: this.config.rpc_username || undefined,
+        rpc_password: this.config.rpc_password || undefined,
+        offlineMode: false,
+        minAmountOfAddresses: 1
+      });
+
+      // Test connection
+      await this.wallet.rpc(RPC_METHODS.GET_BLOCKCHAIN_INFO, []);
+      this.connected = true;
+
+      if (!silent) {
+        console.log('✓ Reconnected to RPC server');
+      }
+
+      return true;
+    } catch (error) {
+      this.connected = false;
+      this.wallet = null;
+      return false;
+    }
+  }
+}

package/src/ui/TerminalUI.js

@@ -0,0 +1,272 @@
+/**
+ * Terminal UI for Neurai DePIN Terminal
+ * Full-screen blessed-based interface with top bar, message area, input, and status bar
+ * @module TerminalUI
+ */
+
+import blessed from 'blessed';
+import {
+  COLORS,
+  ICONS,
+  BLESSED_KEYS,
+  ADDRESS,
+  PRIVACY,
+  TIME
+} from '../constants.js';
+import { formatTimestamp, resetTerminal } from '../utils.js';
+import { TopBar } from './components/TopBar.js';
+import { MessageBox } from './components/MessageBox.js';
+import { InputBox } from './components/InputBox.js';
+import { StatusBar } from './components/StatusBar.js';
+import { ErrorOverlay } from './components/ErrorOverlay.js';
+
+/**
+ * Terminal UI manager using blessed library
+ */
+export class TerminalUI {
+  /**
+   * Create a new TerminalUI instance
+   * @param {Object} config - Configuration object
+   * @param {string} config.rpc_url - RPC server URL
+   * @param {string} config.token - DePIN token name
+   * @param {WalletManager} walletManager - Wallet manager instance
+   * @param {RpcService} rpcService - RPC service instance
+   */
+  constructor(config, walletManager, rpcService) {
+    this.config = config;
+    this.walletManager = walletManager;
+    this.rpcService = rpcService;
+    this.myAddress = walletManager.getAddress();
+    this.sendCallback = null;
+    this.displayedMessages = [];
+    this.hasPrivacy = false;
+    this.encryptionType = PRIVACY.DEFAULT_ENCRYPTION;
+    this.totalMessages = 0;
+    this.lastConnectionStatus = false;
+    this.lastPollTime = null;
+
+    this.initializeScreen();
+    this.createComponents();
+    this.setupKeybindings();
+    this.inputBox.focus();
+    this.screen.render();
+    this.updateTopBar({ connected: false, lastPoll: null });
+  }
+
+  /**
+   * Initialize blessed screen
+   */
+  initializeScreen() {
+    this.screen = blessed.screen({
+      smartCSR: true,
+      title: 'Neurai DePIN Terminal'
+    });
+  }
+
+  /**
+   * Create UI components (top bar, message box, input box, status bar)
+   */
+  createComponents() {
+    this.topBar = new TopBar(this.screen, this.config, this.myAddress);
+    this.messageBox = new MessageBox(this.screen);
+    this.inputBox = new InputBox(this.screen, (msg) => this.handleSend(msg));
+    this.statusBar = new StatusBar(this.screen);
+    this.errorOverlay = new ErrorOverlay(this.screen);
+  }
+
+  /**
+   * Show blocking error overlay
+   * @param {string[]} errors - List of error messages
+   */
+  showBlockingErrors(errors) {
+    this.inputBox.disable();
+    this.errorOverlay.show(errors);
+  }
+
+  /**
+   * Clear blocking error overlay
+   */
+  clearBlockingErrors() {
+    if (this.errorOverlay.isVisible()) {
+      this.errorOverlay.hide();
+      this.inputBox.enable();
+      this.inputBox.focus();
+    }
+  }
+
+  /**
+   * Setup keyboard bindings
+   */
+  setupKeybindings() {
+    // Exit on Ctrl+C or Escape
+    this.screen.key(BLESSED_KEYS.QUIT, () => {
+      this.cleanup();
+      process.exit(0);
+    });
+  }
+
+  /**
+   * Update top bar with connection status and info
+   * @param {Object} status - Status object
+   * @param {boolean} status.connected - Connection status
+   * @param {Date|null} status.lastPoll - Last poll time
+   */
+  updateTopBar(status) {
+    this.lastConnectionStatus = status.connected;
+
+    if (status.lastPoll) {
+      this.lastPollTime = status.lastPoll;
+    }
+
+    this.topBar.update({
+      connected: status.connected,
+      lastPoll: status.lastPoll
+    });
+  }
+
+  /**
+   * Format message line for display
+   * @param {Object} msg - Message object
+   * @returns {string} Formatted message line with blessed tags
+   */
+  formatMessageLine(msg) {
+    const time = formatTimestamp(msg.timestamp, this.config.timezone);
+    const isMe = msg.sender === this.myAddress;
+    const senderLabel = isMe ? 'YOU' : msg.sender.slice(0, ADDRESS.TRUNCATE_LENGTH);
+    const color = isMe ? COLORS.MY_MESSAGE : COLORS.OTHER_MESSAGE;
+
+    return `{${color}}[${time}] ${senderLabel}: ${msg.message}{/}`;
+  }
+
+  /**
+   * Add a new message to the display
+   * Maintains chronological order (oldest to newest)
+   * @param {Object} msg - Message object
+   * @param {string} msg.sender - Sender address
+   * @param {string} msg.message - Message content
+   * @param {number} msg.timestamp - Unix timestamp in seconds
+   * @param {string} msg.hash - Message hash
+   */
+  addMessage(msg) {
+    this.displayedMessages.push(msg);
+
+    // Sort by timestamp (oldest to newest)
+    this.displayedMessages.sort((a, b) => a.timestamp - b.timestamp);
+
+    // Redraw all messages
+    this.redrawMessages();
+  }
+
+  /**
+   * Redraw all messages in the message box
+   */
+  redrawMessages() {
+    const formattedMessages = this.displayedMessages.map(msg => this.formatMessageLine(msg));
+    // Clear and rebuild message box content
+    this.messageBox.component.setContent(formattedMessages.join('\n'));
+    this.messageBox.component.setScrollPerc(100);
+    this.screen.render();
+  }
+
+  /**
+   * Show error message in message box
+   * @param {string} errorMsg - Error message
+   */
+  showError(errorMsg) {
+    const line = `{${COLORS.ERROR}}[ERROR] ${errorMsg}{/}`;
+    this.messageBox.addMessage(line);
+  }
+
+  /**
+   * Show info message in message box
+   * @param {string} infoMsg - Info message
+   */
+  showInfo(infoMsg) {
+    const line = `{${COLORS.INFO}}[INFO] ${infoMsg}{/}`;
+    this.messageBox.addMessage(line);
+  }
+
+  /**
+   * Show success message in message box
+   * @param {string} successMsg - Success message
+   */
+  showSuccess(successMsg) {
+    const line = `{${COLORS.SUCCESS}}[${ICONS.SUCCESS}] ${successMsg}{/}`;
+    this.messageBox.addMessage(line);
+  }
+
+  /**
+   * Update status bar with send status
+   * @param {string} message - Status message
+   * @param {string} [type='info'] - Message type: 'success', 'error', or 'info'
+   */
+  updateSendStatus(message, type = 'info') {
+    this.statusBar.update(message, type);
+  }
+
+  /**
+   * Clear status bar
+   */
+  clearSendStatus() {
+    this.statusBar.update('');
+  }
+
+  /**
+   * Handle send message action
+   * @param {string} message - Message to send
+   */
+  handleSend(message) {
+    if (!message) return;
+
+    if (this.sendCallback) {
+      this.sendCallback(message);
+    }
+  }
+
+  /**
+   * Register callback for send action
+   * @param {Function} callback - Callback function(message)
+   */
+  onSend(callback) {
+    this.sendCallback = callback;
+  }
+
+  /**
+   * Update pool information from depingetmsginfo RPC call
+   * @param {Object} poolInfo - Pool information
+   * @param {number} [poolInfo.messages] - Total messages in pool
+   * @param {string} [poolInfo.cipher] - Encryption cipher name
+   * @param {string} [poolInfo.depinpoolpkey] - Server privacy public key
+   */
+  updatePoolInfo(poolInfo) {
+    if (poolInfo) {
+      this.totalMessages = poolInfo.messages || 0;
+      this.encryptionType = poolInfo.cipher || PRIVACY.DEFAULT_ENCRYPTION;
+      this.hasPrivacy = poolInfo.depinpoolpkey && poolInfo.depinpoolpkey !== PRIVACY.NO_KEY_VALUE;
+      
+      this.topBar.setTotalMessages(this.totalMessages);
+      this.topBar.setEncryptionType(this.encryptionType);
+      
+      // Refresh top bar
+      this.updateTopBar({
+        connected: this.lastConnectionStatus,
+        lastPoll: this.lastPollTime
+      });
+    }
+  }
+
+  /**
+   * Cleanup terminal state
+   * Removes listeners, destroys screen, resets terminal
+   */
+  cleanup() {
+    if (this.screen) {
+      try {
+        this.screen.destroy();
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+      resetTerminal();
+    }
+  }
+}

package/src/ui/components/ErrorOverlay.js

@@ -0,0 +1,99 @@
+import blessed from 'blessed';
+import { COLORS } from '../../constants.js';
+
+export class ErrorOverlay {
+  constructor(screen) {
+    this.screen = screen;
+    this.timer = null;
+    this.timeLeft = 30;
+    this.currentErrors = [];
+    
+    this.component = blessed.box({
+      top: 'center',
+      left: 'center',
+      width: '50%',
+      height: 'shrink',
+      content: '',
+      tags: true,
+      border: {
+        type: 'line'
+      },
+      style: {
+        fg: COLORS.FG_WHITE,
+        bg: COLORS.ERROR,
+        border: {
+          fg: COLORS.FG_WHITE
+        }
+      },
+      hidden: true
+    });
+
+    this.screen.append(this.component);
+  }
+
+  /**
+   * Show blocking error overlay
+   * @param {string[]} errors - List of error messages
+   */
+  show(errors) {
+    if (!errors || errors.length === 0) {
+      this.hide();
+      return;
+    }
+
+    this.currentErrors = errors;
+    this.timeLeft = 30;
+    
+    // Clear existing timer if any
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+
+    this.updateContent();
+    this.component.show();
+    this.component.setFront();
+    this.screen.render();
+
+    // Start countdown
+    this.timer = setInterval(() => {
+      this.timeLeft--;
+      if (this.timeLeft < 0) this.timeLeft = 0;
+      this.updateContent();
+    }, 1000);
+  }
+
+  /**
+   * Update overlay content with current timer
+   */
+  updateContent() {
+    const content = `\n{bold}CRITICAL ERRORS:{/bold}\n\n` +
+      this.currentErrors.map(e => `• ${e}`).join('\n\n') +
+      `\n\n{center}Retrying in ${this.timeLeft}s...{/center}\n`;
+
+    this.component.setContent(content);
+    this.screen.render();
+  }
+
+  /**
+   * Hide blocking error overlay
+   */
+  hide() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+
+    if (!this.component.hidden) {
+      this.component.hide();
+      this.screen.render();
+    }
+  }
+
+  /**
+   * Check if overlay is visible
+   * @returns {boolean} True if visible
+   */
+  isVisible() {
+    return !this.component.hidden;
+  }
+}

package/src/ui/components/InputBox.js

@@ -0,0 +1,63 @@
+import blessed from 'blessed';
+import { UI, COLORS, KEY_CODES } from '../../constants.js';
+
+export class InputBox {
+  constructor(screen, onSend) {
+    this.screen = screen;
+    this.onSend = onSend;
+    
+    this.component = blessed.textarea({
+      bottom: UI.STATUS_BAR_HEIGHT,
+      left: 0,
+      width: '100%',
+      height: UI.INPUT_BOX_HEIGHT,
+      inputOnFocus: true,
+      keys: true,
+      style: {
+        fg: COLORS.FG_WHITE,
+        bg: COLORS.BG_BLACK,
+        border: {
+          fg: COLORS.BORDER
+        }
+      },
+      border: {
+        type: 'line'
+      }
+    });
+
+    this.setupEvents();
+    this.screen.append(this.component);
+  }
+
+  setupEvents() {
+    this.component.key('enter', () => {
+      const message = this.component.getValue().trim();
+      if (message) {
+        this.onSend(message);
+        this.component.clearValue();
+        this.screen.render();
+      }
+    });
+  }
+
+  focus() {
+    if (!this.disabled) {
+      this.component.focus();
+    }
+  }
+
+  disable() {
+    this.disabled = true;
+    this.component.inputOnFocus = false;
+    // Optional: Change style to indicate disabled state
+    this.component.style.border.fg = 'gray';
+    this.screen.render();
+  }
+
+  enable() {
+    this.disabled = false;
+    this.component.inputOnFocus = true;
+    this.component.style.border.fg = COLORS.BORDER;
+    this.screen.render();
+  }
+}

package/src/ui/components/MessageBox.js

@@ -0,0 +1,51 @@
+import blessed from 'blessed';
+import { UI, COLORS } from '../../constants.js';
+
+export class MessageBox {
+  constructor(screen) {
+    this.screen = screen;
+    
+    this.component = blessed.box({
+      top: UI.TOP_BAR_HEIGHT,
+      left: 0,
+      width: '100%',
+      height: `100%-${UI.MESSAGE_BOX_OFFSET}`,
+      scrollable: true,
+      alwaysScroll: true,
+      keys: true,
+      vi: true,
+      mouse: true,
+      tags: true,
+      scrollbar: {
+        ch: UI.SCROLLBAR_CHAR,
+        style: {
+          bg: COLORS.BG_BLUE
+        }
+      },
+      style: {
+        fg: COLORS.FG_WHITE,
+        bg: COLORS.BG_BLACK
+      }
+    });
+
+    this.screen.append(this.component);
+  }
+
+  addMessage(formattedLine) {
+    const current = this.component.getContent();
+    const next = current && current.length > 0 ? `${current}\n${formattedLine}` : formattedLine;
+    this.component.setContent(next);
+    this.component.setScrollPerc(100);
+    this.screen.render();
+  }
+
+  scrollUp() {
+    this.component.scroll(-1);
+    this.screen.render();
+  }
+
+  scrollDown() {
+    this.component.scroll(1);
+    this.screen.render();
+  }
+}

package/src/ui/components/StatusBar.js

@@ -0,0 +1,32 @@
+import blessed from 'blessed';
+import { UI, COLORS } from '../../constants.js';
+
+export class StatusBar {
+  constructor(screen) {
+    this.screen = screen;
+    
+    this.component = blessed.box({
+      bottom: 0,
+      left: 0,
+      width: '100%',
+      height: UI.STATUS_BAR_HEIGHT,
+      content: ' Ready',
+      tags: true,
+      style: {
+        fg: COLORS.FG_WHITE,
+        bg: COLORS.BG_BLUE
+      }
+    });
+
+    this.screen.append(this.component);
+  }
+
+  update(message, type = 'info') {
+    let color = COLORS.INFO;
+    if (type === 'error') color = COLORS.ERROR;
+    if (type === 'success') color = COLORS.SUCCESS;
+
+    this.component.setContent(` {${color}}${message}{/${color}}`);
+    this.screen.render();
+  }
+}