diodejs 0.2.1 → 0.3.0

package/connection.js

@@ -16,6 +16,15 @@ const path = require('path');
 // Add dotenv for environment variables
 require('dotenv').config();
 
+// Try to use native keccak if available (optional perf boost)
+let nativeKeccak = null;
+try {
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  nativeKeccak = require('keccak');
+} catch (_) {
+  // optional dependency; fallback to ethereumjs-util.keccak256
+}
+
 class DiodeConnection extends EventEmitter {
   constructor(host, port, keyLocation = './db/keys.json') {
     super();
@@ -37,6 +46,7 @@ class DiodeConnection extends EventEmitter {
     this.clientSockets = new Map(); // For BindPort
     this.connections = new Map(); // For PublishPort
     this.certPem = null;
+    this._serverEthAddress = null; // cache after first read
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
     
@@ -59,7 +69,7 @@ class DiodeConnection extends EventEmitter {
     this.retryTimeoutId = null;
     
     // Log the reconnection settings
-    logger.info(`Connection settings - Auto Reconnect: ${this.autoReconnect}, Max Retries: ${
+    logger.info(() => `Connection settings - Auto Reconnect: ${this.autoReconnect}, Max Retries: ${
       this.maxRetries === Infinity ? 'Infinity' : this.maxRetries
     }, Retry Delay: ${this.retryDelay}ms, Max Retry Delay: ${this.maxRetryDelay}ms`);
 
@@ -71,7 +81,7 @@ class DiodeConnection extends EventEmitter {
     this.ticketUpdateTimer = null;
     
     // Log the ticket batching settings
-    logger.info(`Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
+    logger.info(() => `Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
   }
 
   connect() {
@@ -96,54 +106,59 @@ class DiodeConnection extends EventEmitter {
       };
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
-        logger.info('Connected to Diode.io server');
+        logger.info(() => 'Connected to Diode.io server');
         // 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}`);
+        }
+        // Start periodic ticket updates now that we are fully connected
+        this._startTicketUpdateTimer();
         // Send the ticketv2 command
         try {
           const ticketCommand = await this.createTicketCommand();
           const response = await this.sendCommand(ticketCommand).catch(reject);
           resolve();
         } catch (error) {
-          logger.error(`Error sending ticket: ${error}`);
+          logger.error(() => `Error sending ticket: ${error}`);
           reject(error);
         }
       });
 
       this.socket.on('data', (data) => {
-        logger.debug(`Received data: ${data.toString('hex')}`);
+        // logger.debug(() => `Received data: ${data.toString('hex')}`);
         try {
           this._handleData(data);
         } catch (error) {
-          logger.error(`Error handling data: ${error}`);
+          logger.error(() => `Error handling data: ${error}`);
         }
       });
 
-      // Start the periodic ticket update timer after successful connection
-      this.socket.on('connect', () => {
-        this._startTicketUpdateTimer();
-      });
+      // No-op: rely on secure handshake callback above for timers/caching
 
       this.socket.on('error', (err) => {
-        logger.error(`Connection error: ${err}`);
+        logger.error(() => `Connection error: ${err}`);
           reject(err);
       });
 
       this.socket.on('end', () => {
-        logger.info('Disconnected from server');
+        logger.info(() => 'Disconnected from server');
         this._handleDisconnect();
       });
 
       this.socket.on('close', (hadError) => {
-        logger.info(`Connection closed${hadError ? ' due to error' : ''}`);
+        logger.info(() => `Connection closed${hadError ? ' due to error' : ''}`);
         this._handleDisconnect();
       });
 
       this.socket.on('timeout', () => {
-        logger.warn('Connection timeout');
+        logger.warn(() => 'Connection timeout');
         this._handleDisconnect();
       });
     });
@@ -156,7 +171,7 @@ class DiodeConnection extends EventEmitter {
     this.retryCount++;
     
     if (this.maxRetries !== Infinity && this.retryCount > this.maxRetries) {
-      logger.error(`Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
+      logger.error(() => `Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
       this.emit('reconnect_failed');
       return;
     }
@@ -164,7 +179,7 @@ class DiodeConnection extends EventEmitter {
     // Calculate delay with exponential backoff
     const delay = Math.min(this.retryDelay * Math.pow(1.5, this.retryCount - 1), this.maxRetryDelay);
     
-    logger.info(`Reconnecting in ${delay}ms... (Attempt ${this.retryCount})`);
+    logger.info(() => `Reconnecting in ${delay}ms... (Attempt ${this.retryCount})`);
     this.emit('reconnecting', { attempt: this.retryCount, delay });
     
     this.retryTimeoutId = setTimeout(() => {
@@ -184,11 +199,11 @@ class DiodeConnection extends EventEmitter {
         .then(() => {
           this.isReconnecting = false;
           this.emit('reconnected');
-          logger.info('Successfully reconnected to Diode.io server');
+          logger.info(() => 'Successfully reconnected to Diode.io server');
         })
         .catch((err) => {
           this.isReconnecting = false;
-          logger.error(`Reconnection attempt failed: ${err}`);
+          logger.error(() => `Reconnection attempt failed: ${err}`);
         });
     }, delay);
   }
@@ -274,7 +289,7 @@ class DiodeConnection extends EventEmitter {
   _handleData(data) {
     // Append new data to the receive buffer
     this.receiveBuffer = Buffer.concat([this.receiveBuffer, data]);
-    logger.debug(`Received data: ${data.toString('hex')}`);
+    // logger.debug(() => `Received data: ${data.toString('hex')}`);
   
     let offset = 0;
     while (offset + 2 <= this.receiveBuffer.length) {
@@ -291,8 +306,9 @@ class DiodeConnection extends EventEmitter {
       offset += 2 + length;
   
       try {
-        const decodedMessage = RLP.decode(Uint8Array.from(messageBuffer));
-        logger.debug(`Decoded message: ${makeReadable(decodedMessage)}`);
+        // Avoid copying: pass Buffer directly to RLP.decode
+        const decodedMessage = RLP.decode(messageBuffer);
+        // logger.debug(() => `Decoded message: ${makeReadable(decodedMessage)}`);
     
         if (Array.isArray(decodedMessage) && decodedMessage.length > 1) {
           const requestIdRaw = decodedMessage[0];
@@ -302,8 +318,8 @@ class DiodeConnection extends EventEmitter {
           const requestId = parseRequestId(requestIdRaw);
     
           // Debug statements
-          logger.debug(`requestIdRaw: ${requestIdRaw}`);
-          logger.debug(`Parsed requestId: ${requestId}`);
+          logger.debug(() => `requestIdRaw: ${requestIdRaw}`);
+          logger.debug(() => `Parsed requestId: ${requestId}`);
     
           if (requestId !== null && this.pendingRequests.has(requestId)) {
             // This is a response to a pending request
@@ -311,14 +327,14 @@ class DiodeConnection extends EventEmitter {
             const responseRaw = responseData[0];
     
             // Debug statements
-            logger.debug(`responseTypeRaw: ${responseTypeRaw}`);
-            logger.debug(`Type of responseTypeRaw: ${typeof responseTypeRaw}`);
+            logger.debug(() => `responseTypeRaw: ${responseTypeRaw}`);
+            logger.debug(() => `Type of responseTypeRaw: ${typeof responseTypeRaw}`);
     
             // Parse responseType
             const responseType = parseResponseType(responseTypeRaw);
     
-            logger.debug(`Received response for requestId: ${requestId}`);
-            logger.debug(`Response Type: '${responseType}'`);
+            logger.debug(() => `Received response for requestId: ${requestId}`);
+            logger.debug(() => `Response Type: '${responseType}'`);
     
             const { resolve, reject } = this.pendingRequests.get(requestId);
             try{
@@ -344,20 +360,20 @@ class DiodeConnection extends EventEmitter {
                 resolve(responseData);
               }
             } catch (error) {
-              logger.error(`Error handling response: ${error}`);
+              logger.error(() => `Error handling response: ${error}`);
             }
             this.pendingRequests.delete(requestId);
           } else {
             // This is an unsolicited message
-            logger.debug(`Received unsolicited message: ${makeReadable(decodedMessage)}`);
+            logger.debug(() => `Received unsolicited message`);
             this.emit('unsolicited', decodedMessage);
           }
         } else {
           // Invalid message format
-          logger.error(`Invalid message format: ${makeReadable(decodedMessage)}`);
+          logger.error(() => `Invalid message format: ${makeReadable(decodedMessage)}`);
         }
       } catch (error) {
-        logger.error(`Error decoding message: ${error}`);
+        logger.error(() => `Error decoding message: ${error}`);
       }
     }
     
@@ -392,21 +408,21 @@ class DiodeConnection extends EventEmitter {
         const requestId = this._getNextRequestId();
         // Build the message as [requestId, [commandArray]]
         const commandWithId = [requestId, commandArray];
-  
+
         // Store the promise callbacks to resolve/reject later
         this.pendingRequests.set(requestId, { resolve, reject });
-  
+
         const commandBuffer = RLP.encode(commandWithId);
-        const byteLength = Buffer.byteLength(commandBuffer);
-  
+        const byteLength = commandBuffer.length; // Buffer/Uint8Array length is bytes
+
         // Create a 2-byte length buffer
         const lengthBuffer = Buffer.alloc(2);
         lengthBuffer.writeUInt16BE(byteLength, 0);
-  
+
         const message = Buffer.concat([lengthBuffer, commandBuffer]);
   
-        logger.debug(`Sending command with requestId ${requestId}: ${commandArray}`);
-        logger.debug(`Command buffer: ${message.toString('hex')}`);
+        logger.debug(() => `Sending command with requestId ${requestId}: ${commandArray}`);
+        // logger.debug(() => `Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
       }).catch(reject);
@@ -419,23 +435,24 @@ class DiodeConnection extends EventEmitter {
         const requestId = sessionId;
         // Build the message as [requestId, [commandArray]]
         const commandWithId = [requestId, commandArray];
-  
+
         // Store the promise callbacks to resolve/reject later
         this.pendingRequests.set(requestId, { resolve, reject });
-  
+
         const commandBuffer = RLP.encode(commandWithId);
-        const byteLength = Buffer.byteLength(commandBuffer);
-  
+        const byteLength = commandBuffer.length; // Buffer/Uint8Array length is bytes
+
         // Create a 2-byte length buffer
         const lengthBuffer = Buffer.alloc(2);
         lengthBuffer.writeUInt16BE(byteLength, 0);
-  
+
         const message = Buffer.concat([lengthBuffer, commandBuffer]);
   
-        logger.debug(`Sending command with requestId ${requestId}: ${commandArray}`);
-        logger.debug(`Command buffer: ${message.toString('hex')}`);
+        logger.debug(() => `Sending command with requestId ${requestId}: ${commandArray}`);
+        // logger.debug(() => `Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
+        resolve();
       }).catch(reject);
     });
   }
@@ -452,13 +469,16 @@ class DiodeConnection extends EventEmitter {
 
       return address;
     } catch (error) {
-      logger.error(`Error extracting Ethereum address: ${error}`);
+      logger.error(() => `Error extracting Ethereum address: ${error}`);
       throw error;
     }
   }
   
   getServerEthereumAddress() {
     try {
+      if (this._serverEthAddress) {
+        return this._serverEthAddress;
+      }
       const serverCert = this.socket.getPeerCertificate(true);
       if (!serverCert.raw) {
         throw new Error('Failed to get server certificate.');
@@ -468,14 +488,14 @@ class DiodeConnection extends EventEmitter {
         ? serverCert.pubkey
         : Buffer.from(serverCert.pubkey);
 
-      logger.debug(`Public key Server: ${publicKeyBuffer.toString('hex')}`);
+      logger.debug(() => `Public key Server: ${publicKeyBuffer.toString('hex')}`);
 
       const addressBuffer = ethUtil.pubToAddress(publicKeyBuffer, true);
       const address = '0x' + addressBuffer.toString('hex');
-
-      return address;
+      this._serverEthAddress = address;
+      return this._serverEthAddress;
     } catch (error) {
-      logger.error(`Error extracting server Ethereum address: ${error}`);
+      logger.error(() => `Error extracting server Ethereum address: ${error}`);
       throw error;
     }
   }
@@ -488,13 +508,12 @@ class DiodeConnection extends EventEmitter {
       const privateKeyBytes = Buffer.from(privateKeyHex, 'hex');
       return privateKeyBytes;
     } catch (error) {
-      logger.error(`Error extracting private key: ${error}`);
+      logger.error(() => `Error extracting private key: ${error}`);
       throw error;
     }
   }
 
   async createTicketSignature(serverIdBuffer, totalConnections, totalBytes, localAddress, epoch) { 
-    this.getEthereumAddress()
     const chainId = 1284;
     const fleetContractBuffer = ethUtil.toBuffer('0x6000000000000000000000000000000000000000'); // 20-byte Buffer
   
@@ -512,23 +531,25 @@ class DiodeConnection extends EventEmitter {
       ethUtil.setLengthLeft(localAddressHash, 32),
     ];
 
-    // Convert each element in dataToSign to bytes32 and concatenate them
-    const encodedData = Buffer.concat(dataToSign.map(item => abi.rawEncode(['bytes32'], [item])));
+    // Elements are already bytes32; concatenate directly to avoid ABI overhead
+    const encodedData = Buffer.concat(dataToSign);
 
-    logger.debug(`Encoded data: ${encodedData.toString('hex')}`);
+    logger.debug(() => `Encoded data: ${encodedData.toString('hex')}`);
 
-    logger.debug(`Data to sign: ${makeReadable(dataToSign)}`);
+    logger.debug(() => `Data to sign: ${makeReadable(dataToSign)}`);
   
   
     // Sign the data
     const privateKey = this.getPrivateKey();
-    const msgHash = ethUtil.keccak256(encodedData);
-    logger.debug(`Message hash: ${msgHash.toString('hex')}`);
+    const msgHash = nativeKeccak
+      ? nativeKeccak('keccak256').update(encodedData).digest()
+      : ethUtil.keccak256(encodedData);
+    logger.debug(() => `Message hash: ${msgHash.toString('hex')}`);
     const signature = secp256k1.ecdsaSign(msgHash, privateKey);
-    logger.debug(`Signature: ${signature.signature.toString('hex')}`);
+    logger.debug(() => `Signature: ${signature.signature.toString('hex')}`);
     
     const signatureBuffer = Buffer.concat([
-      ethUtil.toBuffer([signature.recid]),
+      Buffer.from([signature.recid]),
       signature.signature
     ]);
 
@@ -559,7 +580,7 @@ class DiodeConnection extends EventEmitter {
       localAddress,
       epoch
     );
-    logger.debug(`Signature hex: ${signature.toString('hex')}`);
+    logger.debug(() => `Signature hex: ${signature.toString('hex')}`);
 
   
     // Construct the ticket command
@@ -644,21 +665,22 @@ class DiodeConnection extends EventEmitter {
     const timeSinceLastUpdate = Date.now() - this.lastTicketUpdate;
     
     if (force || 
-        this.accumulatedBytes >= this.ticketUpdateThreshold || 
-        timeSinceLastUpdate >= this.ticketUpdateInterval) {
+      (this.accumulatedBytes > 0 && 
+      (this.accumulatedBytes >= this.ticketUpdateThreshold || 
+      timeSinceLastUpdate >= this.ticketUpdateInterval))) {
       
       try {
-        if (this.accumulatedBytes > 0 || force) {
-          logger.debug(`Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
-          const ticketCommand = await this.createTicketCommand();
-          await this.sendCommand(ticketCommand);
-          
-          // Reset counters
-          this.accumulatedBytes = 0;
-          this.lastTicketUpdate = Date.now();
-        }
+      if (this.accumulatedBytes > 0 || force) {
+        logger.debug(() => `Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
+        const ticketCommand = await this.createTicketCommand();
+        await this.sendCommand(ticketCommand);
+        
+        // Reset counters
+        this.accumulatedBytes = 0;
+        this.lastTicketUpdate = Date.now();
+      }
       } catch (error) {
-        logger.error(`Error updating ticket: ${error}`);
+      logger.error(() => `Error updating ticket: ${error}`);
       }
     }
     
@@ -686,7 +708,7 @@ class DiodeConnection extends EventEmitter {
       this.ticketUpdateInterval = options.interval;
     }
     
-    logger.info(`Updated ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
+    logger.info(() => `Updated ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
     
     // Reset the timer with new interval
     if (this.socket && !this.socket.destroyed) {

package/index.js

@@ -5,4 +5,10 @@ const BindPort = require('./bindPort');
 const PublishPort = require('./publishPort');
 const makeReadable = require('./utils').makeReadable;
 const logger = require('./logger');
+process.on('unhandledRejection', (reason) => {
+  try { logger.warn(() => `Unhandled promise rejection: ${reason}`); } catch {}
+});
+process.on('uncaughtException', (err) => {
+  try { logger.error(() => `Uncaught exception: ${err.stack || err.message}`); } catch {}
+});
 module.exports = { DiodeConnection, DiodeRPC, BindPort , PublishPort, makeReadable, logger };

package/logger.js

@@ -19,10 +19,15 @@ const options = {
 
 const logger = setupLogger(options);
 
+// Evaluate function args lazily to avoid building strings if logs are disabled
+const evalArg = (a) => (typeof a === 'function' ? a() : a);
+const mapArgs = (args) => args.map(evalArg);
+const shouldDebug = isDebug && isLogEnabled;
+
 // Wrap logger calls to respect debug mode
 module.exports = {
-  debug: (...args) => { if (isDebug && isLogEnabled) logger.debug(...args, 'app'); },
-  info: (...args) => { if (isLogEnabled) logger.info(...args, 'app'); },
-  warn: (...args) => { if (isLogEnabled) logger.warn(...args, 'app'); },
-  error: (...args) => { if (isLogEnabled) logger.error(...args, 'app'); },
-};
+  debug: (...args) => { if (shouldDebug) logger.debug(...mapArgs(args), 'app'); },
+  info: (...args) => { if (isLogEnabled) logger.info(...mapArgs(args), 'app'); },
+  warn: (...args) => { if (isLogEnabled) logger.warn(...mapArgs(args), 'app'); },
+  error: (...args) => { if (isLogEnabled) logger.error(...mapArgs(args), 'app'); },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "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": {
@@ -11,20 +11,18 @@
   "dependencies": {
     "@ethereumjs/rlp": "^5.0.2",
     "asn1.js": "^5.4.1",
-    "buffer": "^6.0.3",
-    "crypto": "^1.0.1",
     "dera-logger": "^2.0.0",
-    "dgram": "^1.0.1",
     "dotenv": "^16.4.7",
     "ethereumjs-abi": "^0.6.8",
     "ethereumjs-util": "^7.1.5",
     "ethers": "^6.13.2",
-    "fs": "^0.0.1-security",
     "jsrsasign": "^11.1.0",
-    "net": "^1.0.2",
+    "keccak": "^3.0.4",
     "node-fetch": "^2.7.0",
     "rlp": "^3.0.0",
-    "secp256k1": "^5.0.1",
-    "tls": "^0.0.1"
+    "secp256k1": "^5.0.1"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }