diodejs 0.3.0 → 0.4.0

package/clientManager.js

@@ -0,0 +1,435 @@
+const EventEmitter = require('events');
+const DiodeConnection = require('./connection');
+const DiodeRPC = require('./rpc');
+const logger = require('./logger');
+
+const DEFAULT_DIODE_ADDRS = [
+  'as1.prenet.diode.io:41046',
+  'as2.prenet.diode.io:41046',
+  'us1.prenet.diode.io:41046',
+  'us2.prenet.diode.io:41046',
+  'eu1.prenet.diode.io:41046',
+  'eu2.prenet.diode.io:41046',
+];
+
+function splitHostPort(input, defaultPort) {
+  if (!input || typeof input !== 'string') {
+    return { host: '', port: defaultPort };
+  }
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { host: '', port: defaultPort };
+  }
+
+  if (trimmed.startsWith('[')) {
+    const idx = trimmed.indexOf(']');
+    if (idx !== -1) {
+      const host = trimmed.slice(1, idx);
+      const rest = trimmed.slice(idx + 1);
+      if (rest.startsWith(':')) {
+        const port = parseInt(rest.slice(1), 10);
+        return { host, port: Number.isFinite(port) && port > 0 ? port : defaultPort };
+      }
+      return { host, port: defaultPort };
+    }
+  }
+
+  const lastColon = trimmed.lastIndexOf(':');
+  if (lastColon > -1 && trimmed.indexOf(':') === lastColon) {
+    const host = trimmed.slice(0, lastColon);
+    const portStr = trimmed.slice(lastColon + 1);
+    if (/^\d+$/.test(portStr)) {
+      const port = parseInt(portStr, 10);
+      return { host, port: Number.isFinite(port) && port > 0 ? port : defaultPort };
+    }
+  }
+
+  return { host: trimmed, port: defaultPort };
+}
+
+function joinHostPort(host, port) {
+  if (!host) return '';
+  if (host.includes(':') && !host.startsWith('[')) {
+    return `[${host}]:${port}`;
+  }
+  return `${host}:${port}`;
+}
+
+function normalizeAddress(address) {
+  if (!address) return null;
+  if (Buffer.isBuffer(address)) return address;
+  if (address instanceof Uint8Array) return Buffer.from(address);
+  if (typeof address === 'string') {
+    const hex = address.toLowerCase().startsWith('0x') ? address.slice(2) : address;
+    if (!hex) return Buffer.alloc(0);
+    return Buffer.from(hex, 'hex');
+  }
+  return null;
+}
+
+function normalizeServerIdHex(serverId) {
+  if (!serverId) return '';
+  if (Buffer.isBuffer(serverId) || serverId instanceof Uint8Array) {
+    return `0x${Buffer.from(serverId).toString('hex')}`.toLowerCase();
+  }
+  if (typeof serverId === 'string') {
+    return (serverId.startsWith('0x') ? serverId : `0x${serverId}`).toLowerCase();
+  }
+  return '';
+}
+
+function isConnected(connection) {
+  return connection && connection.socket && !connection.socket.destroyed;
+}
+
+class DiodeClientManager extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.keyLocation = options.keyLocation || './db/keys.json';
+    this.defaultPort = Number.isFinite(options.port) && options.port > 0 ? options.port : 41046;
+    this.deviceCacheTtlMs = Number.isFinite(options.deviceCacheTtlMs)
+      ? options.deviceCacheTtlMs
+      : 30000;
+
+    this.connections = [];
+    this.connectionByHost = new Map();
+    this.serverIdToConnection = new Map();
+    this.pendingConnections = new Map();
+    this.deviceRelayCache = new Map();
+    this._rpcByConnection = new Map();
+    this._rrIndex = 0;
+
+    this.initialHosts = this._buildInitialHosts(options);
+  }
+
+  _buildInitialHosts(options) {
+    if (typeof options.host === 'string' && options.host.trim()) {
+      const { host, port } = splitHostPort(options.host, this.defaultPort);
+      return host ? [joinHostPort(host, port)] : [];
+    }
+
+    let hosts = [];
+    if (Array.isArray(options.hosts)) {
+      hosts = options.hosts;
+    } else if (typeof options.hosts === 'string') {
+      hosts = options.hosts.split(',').map((entry) => entry.trim());
+    }
+
+    if (hosts.length === 0) {
+      hosts = DEFAULT_DIODE_ADDRS.slice();
+    }
+
+    const seen = new Set();
+    const normalized = [];
+    for (const entry of hosts) {
+      if (!entry) continue;
+      const { host, port } = splitHostPort(entry, this.defaultPort);
+      if (!host) continue;
+      const key = joinHostPort(host, port);
+      const lower = key.toLowerCase();
+      if (!seen.has(lower)) {
+        seen.add(lower);
+        normalized.push(key);
+      }
+    }
+    return normalized;
+  }
+
+  _getRpcFor(connection) {
+    if (!connection) return null;
+    let rpc = this._rpcByConnection.get(connection);
+    if (!rpc) {
+      rpc = connection.RPC || new DiodeRPC(connection);
+      this._rpcByConnection.set(connection, rpc);
+    }
+    return rpc;
+  }
+
+  _updateServerIdMapping(connection) {
+    if (!connection) return;
+    try {
+      const serverId = connection.getServerEthereumAddress(true);
+      if (serverId) {
+        this.serverIdToConnection.set(serverId.toLowerCase(), connection);
+      }
+    } catch (error) {
+      logger.debug(() => `Failed to map server ID for ${connection.host}:${connection.port}: ${error}`);
+    }
+  }
+
+  _localAddressHintFor(connection) {
+    const connected = this._connectedConnections();
+    if (connected.length === 0) {
+      return Buffer.alloc(0);
+    }
+    const primary = connected[0];
+    const secondary = connected.length > 1 ? connected[1] : null;
+
+    let primaryId = '';
+    try {
+      primaryId = normalizeServerIdHex(primary.getServerEthereumAddress(true));
+    } catch (_) {
+      primaryId = '';
+    }
+    if (!primaryId) {
+      return Buffer.alloc(0);
+    }
+
+    if (primary === connection) {
+      if (!secondary) return Buffer.alloc(0);
+      let secondaryId = '';
+      try {
+        secondaryId = normalizeServerIdHex(secondary.getServerEthereumAddress(true));
+      } catch (_) {
+        secondaryId = '';
+      }
+      if (!secondaryId) return Buffer.alloc(0);
+      return Buffer.concat([
+        Buffer.from([1]),
+        Buffer.from(secondaryId.slice(2), 'hex'),
+      ]);
+    }
+
+    return Buffer.concat([
+      Buffer.from([0]),
+      Buffer.from(primaryId.slice(2), 'hex'),
+    ]);
+  }
+
+  _registerConnection(connection, hostKey) {
+    connection._managerHostKey = hostKey;
+    this.connections.push(connection);
+    this.connectionByHost.set(hostKey, connection);
+    if (typeof connection.setLocalAddressProvider === 'function') {
+      connection.setLocalAddressProvider(() => this._localAddressHintFor(connection));
+    }
+
+    connection.on('unsolicited', (message) => {
+      this.emit('unsolicited', message, connection);
+    });
+    connection.on('reconnected', () => {
+      this._updateServerIdMapping(connection);
+      this.emit('reconnected', connection);
+    });
+    connection.on('reconnecting', (info) => {
+      this.emit('reconnecting', connection, info);
+    });
+    connection.on('reconnect_failed', () => {
+      this.emit('reconnect_failed', connection);
+    });
+  }
+
+  _unregisterConnection(connection, hostKey) {
+    if (!connection) return;
+    if (hostKey) {
+      this.connectionByHost.delete(hostKey);
+    }
+    this.connections = this.connections.filter((item) => item !== connection);
+    for (const [serverId, conn] of this.serverIdToConnection.entries()) {
+      if (conn === connection) {
+        this.serverIdToConnection.delete(serverId);
+      }
+    }
+    this._rpcByConnection.delete(connection);
+  }
+
+  async _ensureConnection(hostEntry) {
+    const { host, port } = splitHostPort(hostEntry, this.defaultPort);
+    const hostKey = joinHostPort(host, port);
+    if (!host) {
+      throw new Error(`Invalid host entry: ${hostEntry}`);
+    }
+
+    if (this.connectionByHost.has(hostKey)) {
+      return this.connectionByHost.get(hostKey);
+    }
+
+    if (this.pendingConnections.has(hostKey)) {
+      return this.pendingConnections.get(hostKey);
+    }
+
+    const connection = new DiodeConnection(host, port, this.keyLocation);
+    this._registerConnection(connection, hostKey);
+
+    const promise = connection.connect()
+      .then(() => {
+        this._updateServerIdMapping(connection);
+        this.emit('connected', connection);
+        return connection;
+      })
+      .catch((error) => {
+        this._unregisterConnection(connection, hostKey);
+        throw error;
+      })
+      .finally(() => {
+        this.pendingConnections.delete(hostKey);
+      });
+
+    this.pendingConnections.set(hostKey, promise);
+    return promise;
+  }
+
+  _connectedConnections() {
+    return this.connections.filter((connection) => isConnected(connection));
+  }
+
+  getNearestConnection() {
+    const connected = this._connectedConnections();
+    if (connected.length === 0) {
+      return null;
+    }
+    this._rrIndex = (this._rrIndex + 1) % connected.length;
+    return connected[this._rrIndex];
+  }
+
+  async connect() {
+    if (!this.initialHosts || this.initialHosts.length === 0) {
+      throw new Error('No Diode hosts configured');
+    }
+
+    const results = await Promise.allSettled(
+      this.initialHosts.map((host) => this._ensureConnection(host))
+    );
+
+    const success = results.some((result) => result.status === 'fulfilled');
+    if (!success) {
+      const errorMessages = results
+        .filter((result) => result.status === 'rejected')
+        .map((result) => result.reason && result.reason.message ? result.reason.message : String(result.reason));
+      throw new Error(`Failed to connect to any Diode hosts. ${errorMessages.join('; ')}`);
+    }
+
+    return this;
+  }
+
+  async getConnectionForDevice(deviceId) {
+    const deviceIdBuffer = normalizeAddress(deviceId);
+    if (!deviceIdBuffer) {
+      throw new Error('Invalid device ID');
+    }
+    const deviceIdHex = deviceIdBuffer.toString('hex');
+
+    if (this.deviceCacheTtlMs > 0) {
+      const cached = this.deviceRelayCache.get(deviceIdHex);
+      if (cached && Date.now() - cached.ts < this.deviceCacheTtlMs) {
+        const cachedConn = this.serverIdToConnection.get(cached.serverIdHex) ||
+          this.connectionByHost.get(cached.hostKey);
+        if (cachedConn && isConnected(cachedConn)) {
+          return cachedConn;
+        }
+      }
+    }
+
+    const primary = this.getNearestConnection();
+    if (!primary) {
+      throw new Error('No connected relay available');
+    }
+
+    let ticket = null;
+    try {
+      ticket = await this._getRpcFor(primary).getObject(deviceIdBuffer);
+    } catch (error) {
+      logger.warn(() => `Failed to resolve device ticket: ${error}`);
+      return primary;
+    }
+
+    const serverIdHex = normalizeServerIdHex(ticket && (ticket.serverIdHex || ticket.serverId));
+    if (!serverIdHex) {
+      return primary;
+    }
+
+    const existing = this.serverIdToConnection.get(serverIdHex);
+    if (existing && isConnected(existing)) {
+      this.deviceRelayCache.set(deviceIdHex, {
+        serverIdHex,
+        hostKey: existing._managerHostKey || '',
+        ts: Date.now(),
+      });
+      return existing;
+    }
+
+    let nodeInfo = null;
+    try {
+      const nodeId = Buffer.from(serverIdHex.slice(2), 'hex');
+      nodeInfo = await this._getRpcFor(primary).getNode(nodeId);
+    } catch (error) {
+      logger.warn(() => `Failed to resolve relay node for ${serverIdHex}: ${error}`);
+      return primary;
+    }
+
+    if (!nodeInfo || !nodeInfo.host) {
+      return primary;
+    }
+
+    const relayPort = nodeInfo.edgePort || nodeInfo.serverPort;
+    if (!relayPort) {
+      return primary;
+    }
+
+    const hostKey = joinHostPort(nodeInfo.host, relayPort);
+    let relayConnection;
+    try {
+      relayConnection = await this._ensureConnection(hostKey);
+    } catch (error) {
+      logger.warn(() => `Failed to connect to relay ${hostKey}: ${error}`);
+      return primary;
+    }
+
+    this.deviceRelayCache.set(deviceIdHex, {
+      serverIdHex,
+      hostKey,
+      ts: Date.now(),
+    });
+
+    return relayConnection || primary;
+  }
+
+  async resolveRelayForDevice(deviceId) {
+    const deviceIdBuffer = normalizeAddress(deviceId);
+    if (!deviceIdBuffer) {
+      throw new Error('Invalid device ID');
+    }
+
+    const primary = this.getNearestConnection();
+    if (!primary) {
+      throw new Error('No connected relay available');
+    }
+
+    const ticket = await this._getRpcFor(primary).getObject(deviceIdBuffer);
+    const serverIdHex = normalizeServerIdHex(ticket && (ticket.serverIdHex || ticket.serverId));
+    if (!serverIdHex) {
+      throw new Error('Device ticket missing server ID');
+    }
+
+    const nodeId = Buffer.from(serverIdHex.slice(2), 'hex');
+    const nodeInfo = await this._getRpcFor(primary).getNode(nodeId);
+    if (!nodeInfo || !nodeInfo.host) {
+      throw new Error('Relay node info missing host');
+    }
+    const relayPort = nodeInfo.edgePort || nodeInfo.serverPort;
+    if (!relayPort) {
+      throw new Error('Relay node info missing port');
+    }
+
+    return {
+      serverId: serverIdHex,
+      host: nodeInfo.host,
+      port: relayPort,
+    };
+  }
+
+  getConnections() {
+    return this.connections.slice();
+  }
+
+  close() {
+    for (const connection of this.connections) {
+      try {
+        connection.close();
+      } catch (_) {}
+    }
+  }
+}
+
+module.exports = DiodeClientManager;

package/connection.js

@@ -3,7 +3,7 @@ const tls = require('tls');
 const fs = require('fs');
 const { RLP } = require('@ethereumjs/rlp');
 const EventEmitter = require('events');
-const { makeReadable, parseRequestId, parseResponseType, parseReason, generateCert, ensureDirectoryExistence, loadOrGenerateKeyPair } = require('./utils');
+const { makeReadable, parseRequestId, parseResponseType, parseReason, parseUInt, generateCert, ensureDirectoryExistence, loadOrGenerateKeyPair, toBufferView } = require('./utils');
 const { Buffer } = require('buffer'); // Import Buffer
 const asn1 = require('asn1.js');
 const secp256k1 = require('secp256k1');
@@ -47,6 +47,7 @@ class DiodeConnection extends EventEmitter {
     this.connections = new Map(); // For PublishPort
     this.certPem = null;
     this._serverEthAddress = null; // cache after first read
+    this.localAddressProvider = null;
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
     
@@ -82,6 +83,12 @@ class DiodeConnection extends EventEmitter {
     
     // Log the ticket batching settings
     logger.info(() => `Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
+
+    // Handle server ticket requests on the API socket
+    this._onUnsolicited = (message) => {
+      this._handleUnsolicitedMessage(message);
+    };
+    this.on('unsolicited', this._onUnsolicited);
   }
 
   connect() {
@@ -106,17 +113,18 @@ class DiodeConnection extends EventEmitter {
       };
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
-        logger.info(() => 'Connected to Diode.io server');
+        const relayHost = this.getServerRelayHost();
+        const relayPort = (this.socket && this.socket.remotePort) ? this.socket.remotePort : this.port;
+        logger.info(() => `Connected to Diode relay ${relayHost}:${relayPort}`);
         // Reset retry counter on successful connection
         this.retryCount = 0;
         // Set keep-alive to prevent connection timeout forever
         this.socket.setKeepAlive(true, 1500);
         this.socket.setNoDelay(true);
         // Cache server address after handshake
-        try {
-          this._serverEthAddress = this.getServerEthereumAddress();
-        } catch (e) {
-          logger.warn(() => `Failed caching server address: ${e}`);
+        const cachedServerAddress = await this._waitForServerEthereumAddress();
+        if (cachedServerAddress) {
+          this._serverEthAddress = cachedServerAddress;
         }
         // Start periodic ticket updates now that we are fully connected
         this._startTicketUpdateTimer();
@@ -269,6 +277,12 @@ class DiodeConnection extends EventEmitter {
     return this;
   }
 
+  // Optional provider for LocalAddr ticket hint (Buffer or string)
+  setLocalAddressProvider(provider) {
+    this.localAddressProvider = typeof provider === 'function' ? provider : null;
+    return this;
+  }
+
   // Update close method to prevent reconnection when intentionally closing
   close() {
     if (this.ticketUpdateTimer) {
@@ -382,6 +396,34 @@ class DiodeConnection extends EventEmitter {
     this.receiveBuffer = this.receiveBuffer.slice(offset);
   }
 
+  _handleUnsolicitedMessage(message) {
+    if (!Array.isArray(message) || message.length < 2) return;
+    const messageContent = message[1];
+    if (!Array.isArray(messageContent) || messageContent.length < 1) return;
+
+    const messageTypeRaw = messageContent[0];
+    const messageType = toBufferView(messageTypeRaw).toString('utf8');
+
+    if (messageType === 'ticket_request') {
+      const deviceUsageRaw = messageContent[1];
+      const deviceUsage = parseUInt(deviceUsageRaw);
+      if (typeof deviceUsage === 'number' && deviceUsage > this.totalBytes) {
+        this.totalBytes = deviceUsage;
+      }
+
+      // Send a fresh ticket promptly to avoid disconnect
+      this.createTicketCommand()
+        .then((ticketCommand) => this.sendCommand(ticketCommand))
+        .then(() => {
+          this.accumulatedBytes = 0;
+          this.lastTicketUpdate = Date.now();
+        })
+        .catch((error) => {
+          logger.error(() => `Error handling ticket_request: ${error}`);
+        });
+    }
+  }
+
   fixResponse(response) {
     /* response is : 
     [
@@ -474,14 +516,18 @@ class DiodeConnection extends EventEmitter {
     }
   }
   
-  getServerEthereumAddress() {
+  getServerEthereumAddress(quiet = false) {
     try {
       if (this._serverEthAddress) {
         return this._serverEthAddress;
       }
       const serverCert = this.socket.getPeerCertificate(true);
       if (!serverCert.raw) {
-        throw new Error('Failed to get server certificate.');
+        const err = new Error('Failed to get server certificate.');
+        if (!quiet) {
+          throw err;
+        }
+        return null;
       }
 
       const publicKeyBuffer = Buffer.isBuffer(serverCert.pubkey)
@@ -495,9 +541,40 @@ class DiodeConnection extends EventEmitter {
       this._serverEthAddress = address;
       return this._serverEthAddress;
     } catch (error) {
-      logger.error(() => `Error extracting server Ethereum address: ${error}`);
-      throw error;
+      if (!quiet) {
+        logger.error(() => `Error extracting server Ethereum address: ${error}`);
+        throw error;
+      }
+      return null;
+    }
+  }
+
+  getServerRelayHost() {
+    if (this.socket && this.socket.remoteAddress) {
+      const address = this.socket.remoteAddress;
+      if (address.startsWith('::ffff:')) {
+        return address.slice(7);
+      }
+      if (address.includes(':')) {
+        return this.host;
+      }
+      return address;
+    }
+    return this.host;
+  }
+
+  async _waitForServerEthereumAddress(options = {}) {
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 2000;
+    const intervalMs = Number.isFinite(options.intervalMs) ? options.intervalMs : 50;
+    const start = Date.now();
+    let address = this.getServerEthereumAddress(true);
+    if (address) return address;
+    while (Date.now() - start < timeoutMs) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      address = this.getServerEthereumAddress(true);
+      if (address) return address;
     }
+    return null;
   }
 
   // Method to extract private key bytes from keyPair
@@ -517,8 +594,10 @@ class DiodeConnection extends EventEmitter {
     const chainId = 1284;
     const fleetContractBuffer = ethUtil.toBuffer('0x6000000000000000000000000000000000000000'); // 20-byte Buffer
   
-    // Hash of localAddress (empty string)
-    const localAddressHash = crypto.createHash('sha256').update(Buffer.from(localAddress, 'utf8')).digest();
+    const localAddressBytes = Buffer.isBuffer(localAddress) || localAddress instanceof Uint8Array
+      ? toBufferView(localAddress)
+      : Buffer.from(localAddress || '', 'utf8');
+    const localAddressHash = crypto.createHash('sha256').update(localAddressBytes).digest();
   
     // Data to sign
     const dataToSign = [
@@ -559,7 +638,18 @@ class DiodeConnection extends EventEmitter {
   async createTicketCommand() {
     const chainId = 1284;
     const fleetContract = ethUtil.toBuffer('0x6000000000000000000000000000000000000000')
-    const localAddress = 'test2'; // Always empty string
+    let localAddress = '';
+    if (typeof this.localAddressProvider === 'function') {
+      try {
+        localAddress = this.localAddressProvider();
+      } catch (error) {
+        logger.warn(() => `Failed to get local address hint: ${error}`);
+        localAddress = '';
+      }
+    }
+    if (localAddress === null || localAddress === undefined) {
+      localAddress = '';
+    }
   
     // Increment totalConnections
     this.totalConnections += 1;
@@ -569,7 +659,10 @@ class DiodeConnection extends EventEmitter {
     const totalBytes = this.totalBytes;
   
     // Get server Ethereum address as Buffer
-    const serverIdBuffer = this.getServerEthereumAddress();
+    const serverIdBuffer = await this._waitForServerEthereumAddress();
+    if (!serverIdBuffer) {
+      throw new Error('Failed to get server certificate.');
+    }
 
     // Get epoch
     const epoch = await this.RPC.getEpoch();

package/examples/RPCTest.js

@@ -1,14 +1,16 @@
-const { DiodeConnection, DiodeRPC } = require('../index');
+const { DiodeClientManager, DiodeRPC } = require('../index');
 const { makeReadable } = require('../utils');
 
 async function main() {
-  const host = 'us2.prenet.diode.io';
-  const port = 41046;
   const keyLocation = './db/keys.json';
 
-  const connection = new DiodeConnection(host, port, keyLocation);
-  await connection.connect();
-  const rpc = connection.RPC;
+  const client = new DiodeClientManager({ keyLocation });
+  await client.connect();
+  const [connection] = client.getConnections();
+  if (!connection) {
+    throw new Error('No relay connection available');
+  }
+  const rpc = connection.RPC || new DiodeRPC(connection);
 
   try {
     const address = connection.getEthereumAddress();
@@ -22,7 +24,7 @@ async function main() {
   } catch (error) {
     console.error('RPC Error:', error);
   } finally {
-    connection.close();
+    client.close();
   }
 }