diodejs 0.4.0 → 0.4.2

package/connection.js

@@ -3,7 +3,19 @@ const tls = require('tls');
 const fs = require('fs');
 const { RLP } = require('@ethereumjs/rlp');
 const EventEmitter = require('events');
-const { makeReadable, parseRequestId, parseResponseType, parseReason, parseUInt, generateCert, ensureDirectoryExistence, loadOrGenerateKeyPair, toBufferView } = require('./utils');
+const {
+  makeReadable,
+  parseRequestId,
+  parseResponseType,
+  parseReason,
+  parseUInt,
+  generateCert,
+  ensureDirectoryExistence,
+  loadOrGenerateKeyPair,
+  toBufferView,
+  DEFAULT_FLEET_CONTRACT,
+  normalizeFleetContractAddress,
+} = require('./utils');
 const { Buffer } = require('buffer'); // Import Buffer
 const asn1 = require('asn1.js');
 const secp256k1 = require('secp256k1');
@@ -48,6 +60,8 @@ class DiodeConnection extends EventEmitter {
     this.certPem = null;
     this._serverEthAddress = null; // cache after first read
     this.localAddressProvider = null;
+    this.fleetContractHex = DEFAULT_FLEET_CONTRACT;
+    this.fleetContract = Buffer.from(DEFAULT_FLEET_CONTRACT.slice(2), 'hex');
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
     
@@ -283,6 +297,13 @@ class DiodeConnection extends EventEmitter {
     return this;
   }
 
+  setFleetContract(fleetContract) {
+    const normalizedFleetContract = normalizeFleetContractAddress(fleetContract);
+    this.fleetContractHex = normalizedFleetContract;
+    this.fleetContract = Buffer.from(normalizedFleetContract.slice(2), 'hex');
+    return this;
+  }
+
   // Update close method to prevent reconnection when intentionally closing
   close() {
     if (this.ticketUpdateTimer) {
@@ -592,7 +613,7 @@ class DiodeConnection extends EventEmitter {
 
   async createTicketSignature(serverIdBuffer, totalConnections, totalBytes, localAddress, epoch) { 
     const chainId = 1284;
-    const fleetContractBuffer = ethUtil.toBuffer('0x6000000000000000000000000000000000000000'); // 20-byte Buffer
+    const fleetContractBuffer = this.fleetContract;
   
     const localAddressBytes = Buffer.isBuffer(localAddress) || localAddress instanceof Uint8Array
       ? toBufferView(localAddress)
@@ -637,7 +658,7 @@ class DiodeConnection extends EventEmitter {
 
   async createTicketCommand() {
     const chainId = 1284;
-    const fleetContract = ethUtil.toBuffer('0x6000000000000000000000000000000000000000')
+    const fleetContract = this.fleetContract;
     let localAddress = '';
     if (typeof this.localAddressProvider === 'function') {
       try {

package/examples/RPCTest.js

@@ -3,8 +3,13 @@ const { makeReadable } = require('../utils');
 
 async function main() {
   const keyLocation = './db/keys.json';
+  const fleetContract = process.env.DIODE_FLEET_CONTRACT;
+  const nextFleetContract = process.env.DIODE_NEXT_FLEET_CONTRACT;
 
-  const client = new DiodeClientManager({ keyLocation });
+  const client = new DiodeClientManager({
+    keyLocation,
+    ...(fleetContract ? { fleetContract } : {}),
+  });
   await client.connect();
   const [connection] = client.getConnections();
   if (!connection) {
@@ -15,6 +20,11 @@ async function main() {
   try {
     const address = connection.getEthereumAddress();
     console.log('Address:', address);
+    console.log('Current fleet contract:', connection.fleetContractHex);
+    if (nextFleetContract) {
+      client.setFleetContract(nextFleetContract);
+      console.log('Updated fleet contract for future tickets:', connection.fleetContractHex);
+    }
     const ping = await rpc.ping();
     console.log('Ping:', ping);
     const blockPeak = await rpc.getBlockPeak();

package/examples/fleetContractExample.js

@@ -0,0 +1,45 @@
+const { DiodeClientManager } = require('../index');
+
+const keyLocation = './db/keys.json';
+const initialFleetContract = process.env.DIODE_FLEET_CONTRACT || '0x1111111111111111111111111111111111111111';
+const nextFleetContract = process.env.DIODE_NEXT_FLEET_CONTRACT || '0x2222222222222222222222222222222222222222';
+const shouldConnect = process.env.DIODE_CONNECT === 'true';
+
+async function main() {
+  const client = new DiodeClientManager({
+    keyLocation,
+    fleetContract: initialFleetContract,
+  });
+
+  console.log('Initial manager fleet contract:', client.fleetContract);
+
+  if (!shouldConnect) {
+    client.setFleetContract(nextFleetContract);
+    console.log('Updated manager fleet contract:', client.fleetContract);
+    console.log('Set DIODE_CONNECT=true to connect and observe the updated contract on active relay connections.');
+    return;
+  }
+
+  try {
+    await client.connect();
+    console.log(`Connected relay count: ${client.getConnections().length}`);
+    for (const connection of client.getConnections()) {
+      console.log(`Before update ${connection.host}:${connection.port} fleet contract: ${connection.fleetContractHex}`);
+    }
+
+    client.setFleetContract(nextFleetContract);
+    console.log('Updated manager fleet contract:', client.fleetContract);
+    for (const connection of client.getConnections()) {
+      console.log(`After update ${connection.host}:${connection.port} fleet contract: ${connection.fleetContractHex}`);
+    }
+
+    console.log('The new fleet contract will be used on the next ticket generated by each connection.');
+  } finally {
+    client.close();
+  }
+}
+
+main().catch((error) => {
+  console.error('Fleet contract example failed:', error);
+  process.exitCode = 1;
+});

package/examples/publishPortTest.js

@@ -10,9 +10,10 @@ async function startPublishing() {
 
   // Create a PublishPort instance with initial ports
   const publishPort = new PublishPort(client, {
-    3000: { mode: 'public' },
+    3000: { mode: 'public', host: '192.168.1.10' },
     8080: { 
       mode: 'private',
+      host: 'backend.internal',
       whitelist: ['0xca1e71d8105a598810578fb6042fa8cbc1e7f039'] // Replace with actual addresses
     }
   }, keyLocation);
@@ -29,7 +30,7 @@ async function startPublishing() {
   // After 15 seconds, add multiple ports
   setTimeout(() => {
     console.log("Adding multiple ports");
-    publishPort.addPort(3000,{ mode: 'public' });
+    publishPort.addPort(3000,{ mode: 'public', host: '127.0.0.1' });
     console.log('Updated published ports:', publishPort.getPublishedPorts());
   }, 15000);
   

package/networkDiscoveryClient.js

@@ -0,0 +1,89 @@
+const WebSocket = require('ws');
+
+function fetchNetworkDirectory(options = {}) {
+  const endpoint = typeof options.endpoint === 'string' && options.endpoint.trim()
+    ? options.endpoint
+    : 'wss://prenet.diode.io:8443/ws';
+  const method = typeof options.method === 'string' && options.method.trim()
+    ? options.method
+    : 'dio_network';
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+    ? Math.floor(options.timeoutMs)
+    : 1500;
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let socket = null;
+    let timer = null;
+
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (socket) {
+        socket.removeAllListeners();
+        try {
+          socket.close();
+        } catch (_) {}
+        socket = null;
+      }
+    };
+
+    const finish = (fn, value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      fn(value);
+    };
+
+    socket = new WebSocket(endpoint, {
+      handshakeTimeout: timeoutMs,
+      origin: 'https://diode.io',
+    });
+
+    socket.on('open', () => {
+      socket.send(JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method,
+        params: [],
+      }));
+    });
+
+    socket.on('message', (raw) => {
+      try {
+        const parsed = JSON.parse(typeof raw === 'string' ? raw : raw.toString('utf8'));
+        if (parsed && parsed.id === 1) {
+          if (parsed.error) {
+            finish(reject, new Error(parsed.error.message || 'Network discovery request failed'));
+            return;
+          }
+          finish(resolve, Array.isArray(parsed.result) ? parsed.result : []);
+        }
+      } catch (error) {
+        finish(reject, error);
+      }
+    });
+
+    socket.on('error', (error) => {
+      finish(reject, error);
+    });
+
+    socket.on('close', () => {
+      if (!settled) {
+        finish(reject, new Error('Network discovery socket closed before a response was received'));
+      }
+    });
+
+    timer = setTimeout(() => {
+      finish(reject, new Error(`Network discovery timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+}
+
+module.exports = {
+  fetchNetworkDirectory,
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "diodejs",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "A JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test"
   },
   "author": "",
   "license": "ISC",
@@ -20,7 +20,8 @@
     "keccak": "^3.0.4",
     "node-fetch": "^2.7.0",
     "rlp": "^3.0.0",
-    "secp256k1": "^5.0.1"
+    "secp256k1": "^5.0.1",
+    "ws": "^8.19.0"
   },
   "engines": {
     "node": ">=18"

package/publishPort.js

@@ -38,6 +38,25 @@ function normalizeDeviceId(raw) {
   return '';
 }
 
+function normalizePublishedPortConfig(config = {}) {
+  const hasHost = Object.prototype.hasOwnProperty.call(config, 'host');
+  const rawHost = hasHost ? config.host : '127.0.0.1';
+  if (typeof rawHost !== 'string') {
+    throw new TypeError('PublishPort config.host must be a non-empty string');
+  }
+
+  const host = rawHost.trim();
+  if (!host) {
+    throw new TypeError('PublishPort config.host must be a non-empty string');
+  }
+
+  return {
+    mode: config.mode || 'public',
+    whitelist: Array.isArray(config.whitelist) ? config.whitelist : [],
+    host,
+  };
+}
+
 class DiodeSocket extends Duplex {
   constructor(ref, rpc) {
     super({ readableHighWaterMark: 256 * 1024, writableHighWaterMark: 256 * 1024, allowHalfOpen: false });
@@ -93,14 +112,11 @@ class PublishPort extends EventEmitter {
     const portNum = parseInt(port, 10);
     
     // Normalize the configuration
-    const portConfig = {
-      mode: config.mode || 'public',
-      whitelist: Array.isArray(config.whitelist) ? config.whitelist : []
-    };
+    const portConfig = normalizePublishedPortConfig(config);
     
     // Add to map
     this.publishedPorts.set(portNum, portConfig);
-    logger.info(() => `Added published port ${portNum} with mode: ${portConfig.mode}`);
+    logger.info(() => `Added published port ${portNum} with mode: ${portConfig.mode}, host: ${portConfig.host}`);
     
     return true;
   }
@@ -186,6 +202,10 @@ class PublishPort extends EventEmitter {
     return rpc;
   }
 
+  _getPublishedPortConfig(port) {
+    return this.publishedPorts.get(port);
+  }
+
   startListening() {
     if (this._listening) return this; // idempotent
     // Listen for unsolicited messages from the connection
@@ -269,7 +289,7 @@ class PublishPort extends EventEmitter {
     }
 
     // Get port configuration and check whitelist if in private mode
-    const portConfig = this.publishedPorts.get(port);
+    const portConfig = this._getPublishedPortConfig(port);
     if (portConfig.mode === 'private' && Array.isArray(portConfig.whitelist)) {
       if (!portConfig.whitelist.includes(deviceId)) {
         logger.warn(() => `Device ${deviceId} is not whitelisted for port ${port}. Rejecting request.`);
@@ -281,15 +301,15 @@ class PublishPort extends EventEmitter {
 
     // Handle based on protocol
     if (protocol === 'tcp') {
-      this.handleTCPConnection(sessionId, ref, port, deviceId, connection);
+      this.handleTCPConnection(sessionId, ref, port, deviceId, portConfig, connection);
     } else if (protocol === 'tls') {
       if (isHandshake) {
         this.handleTLSHandshake(sessionId, ref, port, deviceId, connection);
       } else {
-        this.handleTLSConnection(sessionId, ref, port, deviceId, connection);
+        this.handleTLSConnection(sessionId, ref, port, deviceId, portConfig, connection);
       }
     } else if (protocol === 'udp') {
-      this.handleUDPConnection(sessionId, ref, port, deviceId, connection);
+      this.handleUDPConnection(sessionId, ref, port, deviceId, portConfig, connection);
     } else {
       logger.warn(() => `Unsupported protocol: ${protocol}`);
       rpc.sendError(sessionId, ref, `Unsupported protocol: ${protocol}`);
@@ -449,7 +469,7 @@ class PublishPort extends EventEmitter {
     }
 
     // Get port configuration and check whitelist if in private mode
-    const portConfig = this.publishedPorts.get(port);
+    const portConfig = this._getPublishedPortConfig(port);
     if (portConfig.mode === 'private' && Array.isArray(portConfig.whitelist)) {
       if (!portConfig.whitelist.includes(deviceId)) {
         logger.warn(() => `Device ${deviceId} is not whitelisted for port ${port}. Rejecting request.`);
@@ -473,6 +493,7 @@ class PublishPort extends EventEmitter {
     const session = {
       physicalPort,
       port,
+      host: portConfig.host,
       protocol,
       deviceId: deviceId.toLowerCase(),
       connection,
@@ -527,7 +548,7 @@ class PublishPort extends EventEmitter {
 
   handleNativeTCPRelay(sessionId, physicalPortRef, session, connection) {
     const rpc = this._getRpcFor(connection);
-    const { physicalPort, port, deviceId } = session;
+    const { physicalPort, port, host, deviceId } = session;
     let responded = false;
     const sendOk = () => {
       if (responded) return;
@@ -544,7 +565,7 @@ class PublishPort extends EventEmitter {
     const relaySocket = net.connect({ host: relayHost, port: physicalPort }, () => {
       relaySocket.setNoDelay(true);
     });
-    const localSocket = net.connect({ port }, () => {
+    const localSocket = net.connect({ port, host }, () => {
       localSocket.setNoDelay(true);
     });
     localSocket.pause();
@@ -616,7 +637,7 @@ class PublishPort extends EventEmitter {
 
   handleNativeUDPRelay(sessionId, physicalPortRef, session, connection) {
     const rpc = this._getRpcFor(connection);
-    const { physicalPort, port, deviceId } = session;
+    const { physicalPort, port, host, deviceId } = session;
     let responded = false;
     const sendOk = () => {
       if (responded) return;
@@ -672,7 +693,7 @@ class PublishPort extends EventEmitter {
       relayReady = true;
       maybeReady();
     });
-    localSocket.connect(port, '127.0.0.1', () => {
+    localSocket.connect(port, host, () => {
       localReady = true;
       maybeReady();
     });
@@ -706,12 +727,12 @@ class PublishPort extends EventEmitter {
     }
   }
 
-  handleTCPConnection(sessionId, ref, port, deviceId, connection) {
+  handleTCPConnection(sessionId, ref, port, deviceId, portConfig, connection) {
     const rpc = this._getRpcFor(connection);
     // Create a TCP connection to the local service on the specified port
-    const localSocket = net.connect({ port: port }, () => {
+    const localSocket = net.connect({ port, host: portConfig.host }, () => {
       localSocket.setNoDelay(true);
-      logger.info(() => `Connected to local TCP service on port ${port}`);
+      logger.info(() => `Connected to local TCP service on ${portConfig.host}:${port}`);
       // Send success response
       rpc.sendResponse(sessionId, ref, 'ok');
     });
@@ -720,10 +741,10 @@ class PublishPort extends EventEmitter {
     this.setupLocalSocketHandlers(localSocket, ref, 'tcp', rpc, connection);
 
     // Store the local socket with the ref using connection's method
-    connection.addConnection(ref, { socket: localSocket, protocol: 'tcp', port, deviceId });
+    connection.addConnection(ref, { socket: localSocket, protocol: 'tcp', port, host: portConfig.host, deviceId });
   }
 
-  handleTLSConnection(sessionId, ref, port, deviceId, connection) {
+  handleTLSConnection(sessionId, ref, port, deviceId, portConfig, connection) {
     const rpc = this._getRpcFor(connection);
     // Create a DiodeSocket instance
     const diodeSocket = new DiodeSocket(ref, rpc);
@@ -748,8 +769,8 @@ class PublishPort extends EventEmitter {
     });
     tlsSocket.setNoDelay(true);
     // Connect to the local service (TCP or TLS as needed)
-    const localSocket = net.connect({ port: port }, () => {
-      logger.info(() => `Connected to local TCP service on port ${port}`);
+    const localSocket = net.connect({ port, host: portConfig.host }, () => {
+      logger.info(() => `Connected to local TCP service on ${portConfig.host}:${port}`);
       // Send success response
       rpc.sendResponse(sessionId, ref, 'ok');
     });
@@ -775,11 +796,12 @@ class PublishPort extends EventEmitter {
       localSocket,
       protocol: 'tls',
       port,
+      host: portConfig.host,
       deviceId,
     });
   }
 
-  handleUDPConnection(sessionId, ref, port, deviceId, connection) {
+  handleUDPConnection(sessionId, ref, port, deviceId, portConfig, connection) {
     const rpc = this._getRpcFor(connection);
     // Create a UDP socket
     const localSocket = dgram.createSocket('udp4');
@@ -795,7 +817,7 @@ class PublishPort extends EventEmitter {
     });
 
     // Store the remote address and port from the Diode client
-    const remoteInfo = {port, address: '127.0.0.1'};
+    const remoteInfo = { port, address: portConfig.host };
 
     // Send success response
     rpc.sendResponse(sessionId, ref, 'ok');
@@ -806,10 +828,11 @@ class PublishPort extends EventEmitter {
       protocol: 'udp',
       remoteInfo,
       port,
+      host: portConfig.host,
       deviceId
     });
 
-    logger.info(() => `UDP connection set up on port ${port}`);
+    logger.info(() => `UDP connection set up for ${portConfig.host}:${port}`);
 
     // Handle messages from the local UDP service
     localSocket.on('message', (msg, rinfo) => {
@@ -835,7 +858,7 @@ class PublishPort extends EventEmitter {
     const connectionInfo = connection.getConnection(ref);
     // Check if the port is still open and address is still in whitelist
     if (connectionInfo) {
-      const { socket: localSocket, protocol, remoteInfo, port, deviceId } = connectionInfo;
+      const { socket: localSocket, protocol, remoteInfo, port, host, deviceId } = connectionInfo;
 
       if (!this.publishedPorts.has(port)) {
         logger.warn(() => `Port ${port} is not published. Sending portclose.`);
@@ -844,7 +867,7 @@ class PublishPort extends EventEmitter {
         return;
       }
 
-      const portConfig = this.publishedPorts.get(port);
+      const portConfig = this._getPublishedPortConfig(port);
       if (portConfig.mode === 'private' && Array.isArray(portConfig.whitelist)) {
         if (!portConfig.whitelist.includes(deviceId)) {
           logger.warn(() => `Device ${deviceId} is not whitelisted for port ${port}. Sending portclose.`);
@@ -865,7 +888,7 @@ class PublishPort extends EventEmitter {
 
         // Update remoteInfo if not set
         if (!localSocket.remoteAddress) {
-          localSocket.remoteAddress = '127.0.0.1'; // Assuming local service is on localhost
+          localSocket.remoteAddress = host || (remoteInfo && remoteInfo.address) || portConfig.host;
           localSocket.remotePort = port;
         }
       } else if (protocol === 'tcp') {