diodejs 0.2.2 → 0.3.0

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.2",
+  "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"
   }
 }

package/publishPort.js

@@ -8,12 +8,12 @@ const { Buffer } = require('buffer');
 const EventEmitter = require('events');
 const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
-const { makeReadable } = require('./utils');
+const { makeReadable, toBufferView } = require('./utils');
 const logger = require('./logger');
 
 class DiodeSocket extends Duplex {
   constructor(ref, rpc) {
-    super();
+    super({ readableHighWaterMark: 256 * 1024, writableHighWaterMark: 256 * 1024, allowHalfOpen: false });
     this.ref = ref;
     this.rpc = rpc;
   }
@@ -40,6 +40,7 @@ class PublishPort extends EventEmitter {
     super();
     this.connection = connection;
     this.rpc = new DiodeRPC(connection);
+    this._listening = false; // ensure startListening is idempotent
     
     // Convert publishedPorts to a Map with configurations
     this.publishedPorts = new Map();
@@ -51,9 +52,9 @@ class PublishPort extends EventEmitter {
     
     this.startListening();
     if (this.publishedPorts.size > 0) {
-      logger.info(`Publishing ports: ${Array.from(this.publishedPorts.keys())}`);
+      logger.info(() => `Publishing ports: ${Array.from(this.publishedPorts.keys())}`);
     } else {
-      logger.info("No ports published initially");
+      logger.info(() => "No ports published initially");
     }
   }
 
@@ -69,7 +70,7 @@ class PublishPort extends EventEmitter {
     
     // 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}`);
     
     return true;
   }
@@ -79,7 +80,7 @@ class PublishPort extends EventEmitter {
     const portNum = parseInt(port, 10);
     
     if (!this.publishedPorts.has(portNum)) {
-      logger.warn(`Port ${portNum} is not published`);
+      logger.warn(() => `Port ${portNum} is not published`);
       return false;
     }
     
@@ -90,12 +91,12 @@ class PublishPort extends EventEmitter {
       .filter(conn => conn.port === portNum);
       
     if (activeConnections.length > 0) {
-      logger.warn(`Removing port ${portNum} with ${activeConnections.length} active connections`);
+      logger.warn(() => `Removing port ${portNum} with ${activeConnections.length} active connections`);
       // We could close these connections, but they'll be rejected naturally on next data transfer
     }
     
     this.publishedPorts.delete(portNum);
-    logger.info(`Removed published port ${portNum}`);
+    logger.info(() => `Removed published port ${portNum}`);
     
     return true;
   }
@@ -126,29 +127,41 @@ class PublishPort extends EventEmitter {
   clearPorts() {
     const portCount = this.publishedPorts.size;
     this.publishedPorts.clear();
-    logger.info(`Cleared ${portCount} published ports`);
+    logger.info(() => `Cleared ${portCount} published ports`);
     return portCount;
   }
 
   startListening() {
+    if (this._listening) return this; // idempotent
     // Listen for unsolicited messages from the connection
-    this.connection.on('unsolicited', (message) => {
+    this._onUnsolicited = (message) => {
       const [sessionIdRaw, messageContent] = message;
       const messageTypeRaw = messageContent[0];
-      const messageType = Buffer.from(messageTypeRaw).toString('utf8');
+      const messageType = toBufferView(messageTypeRaw).toString('utf8');
 
       if (messageType === 'portopen') {
         this.handlePortOpen(sessionIdRaw, messageContent);
-      } else if (messageType === 'portsend') {
+      } else if (messageType === 'portsend' || messageType === 'data') {
+        // Accept both synonyms for payload delivery
         this.handlePortSend(sessionIdRaw, messageContent);
       } else if (messageType === 'portclose') {
         this.handlePortClose(sessionIdRaw, messageContent);
       } else {
-        if (messageType != 'data') {
-          logger.warn(`Unknown unsolicited message type: ${messageType}`);
-        }
+        logger.warn(() => `Unknown unsolicited message type: ${messageType}`);
       }
-    });
+    };
+    this.connection.on('unsolicited', this._onUnsolicited);
+    this._listening = true;
+    return this;
+  }
+
+  stopListening() {
+    if (!this._listening) return this;
+    if (this._onUnsolicited) {
+      this.connection.off('unsolicited', this._onUnsolicited);
+    }
+    this._listening = false;
+    return this;
   }
 
   handlePortOpen(sessionIdRaw, messageContent) {
@@ -157,12 +170,12 @@ class PublishPort extends EventEmitter {
     const refRaw = messageContent[2];
     const deviceIdRaw = messageContent[3];
 
-    const sessionId = Buffer.from(sessionIdRaw);
+    const sessionId = toBufferView(sessionIdRaw);
     const portString = makeReadable(portStringRaw);
-    const ref = Buffer.from(refRaw);
-    const deviceId = `0x${Buffer.from(deviceIdRaw).toString('hex')}`;
+    const ref = toBufferView(refRaw);
+    const deviceId = `0x${toBufferView(deviceIdRaw).toString('hex')}`;
 
-    logger.info(`Received portopen request for portString ${portString} with ref ${ref.toString('hex')} from device ${deviceId}`);
+    logger.info(() => `Received portopen request for portString ${portString} with ref ${ref.toString('hex')} from device ${deviceId}`);
 
     // Extract protocol and port number from portString
     var protocol = 'tcp';
@@ -180,7 +193,7 @@ class PublishPort extends EventEmitter {
 
     // Check if the port is published
     if (!this.publishedPorts.has(port)) {
-      logger.warn(`Port ${port} is not published. Rejecting request.`);
+      logger.warn(() => `Port ${port} is not published. Rejecting request.`);
       // Send error response
       this.rpc.sendError(sessionId, ref, 'Port is not published');
       return;
@@ -190,11 +203,11 @@ class PublishPort extends EventEmitter {
     const portConfig = this.publishedPorts.get(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.`);
+        logger.warn(() => `Device ${deviceId} is not whitelisted for port ${port}. Rejecting request.`);
         this.rpc.sendError(sessionId, ref, 'Device not whitelisted');
         return;
       }
-      logger.info(`Device ${deviceId} is whitelisted for port ${port}. Accepting request.`);
+      logger.info(() => `Device ${deviceId} is whitelisted for port ${port}. Accepting request.`);
     }
 
     // Handle based on protocol
@@ -205,7 +218,7 @@ class PublishPort extends EventEmitter {
     } else if (protocol === 'udp') {
       this.handleUDPConnection(sessionId, ref, port, deviceId);
     } else {
-      logger.warn(`Unsupported protocol: ${protocol}`);
+      logger.warn(() => `Unsupported protocol: ${protocol}`);
       this.rpc.sendError(sessionId, ref, `Unsupported protocol: ${protocol}`);
     }
   }
@@ -220,14 +233,14 @@ class PublishPort extends EventEmitter {
       });
 
       localSocket.on('end', () => {
-        logger.info(`Local service disconnected`);
+        logger.info(() => `Local service disconnected`);
         // Send portclose message to Diode
         this.rpc.portClose(ref);
         this.connection.deleteConnection(ref);
       });
 
       localSocket.on('error', (err) => {
-        logger.error(`Error with local service: ${err}`);
+        logger.error(() => `Error with local service: ${err}`);
         // Send portclose message to Diode
         this.rpc.portClose(ref);
         this.connection.deleteConnection(ref);
@@ -238,7 +251,8 @@ class PublishPort extends EventEmitter {
   handleTCPConnection(sessionId, ref, port, deviceId) {
     // Create a TCP connection to the local service on the specified port
     const localSocket = net.connect({ port: port }, () => {
-      logger.info(`Connected to local TCP service on port ${port}`);
+      localSocket.setNoDelay(true);
+      logger.info(() => `Connected to local TCP service on port ${port}`);
       // Send success response
       this.rpc.sendResponse(sessionId, ref, 'ok');
     });
@@ -272,10 +286,10 @@ class PublishPort extends EventEmitter {
       isServer: true,
       ...tlsOptions,
     });
-
+    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}`);
+      logger.info(() => `Connected to local TCP service on port ${port}`);
       // Send success response
       this.rpc.sendResponse(sessionId, ref, 'ok');
     });
@@ -285,7 +299,7 @@ class PublishPort extends EventEmitter {
 
     // Handle errors and cleanup
     tlsSocket.on('error', (err) => {
-      logger.error(`TLS Socket error: ${err}`);
+      logger.error(() => `TLS Socket error: ${err}`);
       this.rpc.portClose(ref);
       this.connection.deleteConnection(ref);
     });
@@ -309,6 +323,16 @@ class PublishPort extends EventEmitter {
     // Create a UDP socket
     const localSocket = dgram.createSocket('udp4');
 
+    // Try larger kernel buffers if available
+    localSocket.on('listening', () => {
+      try {
+        localSocket.setRecvBufferSize(1 << 20); // ~1MB
+        localSocket.setSendBufferSize(1 << 20);
+      } catch (e) {
+        logger.debug(() => `UDP buffer sizing not supported: ${e.message}`);
+      }
+    });
+
     // Store the remote address and port from the Diode client
     const remoteInfo = {port, address: '127.0.0.1'};
 
@@ -324,20 +348,15 @@ class PublishPort extends EventEmitter {
       deviceId
     });
 
-    logger.info(`UDP connection set up on port ${port}`);
+    logger.info(() => `UDP connection set up on port ${port}`);
 
     // Handle messages from the local UDP service
     localSocket.on('message', (msg, rinfo) => {
-      //need to add 4 bytes of data length to the beginning of the message but it's Big Endian
-      const dataLength = Buffer.alloc(4);
-      dataLength.writeUInt32LE(msg.length, 0);
-      const data = Buffer.concat([dataLength, msg]);
-      // Send the data back to the Diode client via portSend
-      this.rpc.portSend(ref, data);
+      this.rpc.portSend(ref, msg);
     });
 
     localSocket.on('error', (err) => {
-      logger.error(`UDP Socket error: ${err}`);
+      logger.error(() => `UDP Socket error: ${err}`);
       this.rpc.portClose(ref);
       this.connection.deleteConnection(ref);
     });
@@ -347,9 +366,9 @@ class PublishPort extends EventEmitter {
     const refRaw = messageContent[1];
     const dataRaw = messageContent[2];
 
-    const sessionId = Buffer.from(sessionIdRaw);
-    const ref = Buffer.from(refRaw);
-    const data = Buffer.from(dataRaw)//.slice(4);
+    const sessionId = toBufferView(sessionIdRaw);
+    const ref = toBufferView(refRaw);
+    const data = toBufferView(dataRaw);//.slice(4);
 
     const connectionInfo = this.connection.getConnection(ref);
     // Check if the port is still open and address is still in whitelist
@@ -357,7 +376,7 @@ class PublishPort extends EventEmitter {
       const { socket: localSocket, protocol, remoteInfo, port, deviceId } = connectionInfo;
 
       if (!this.publishedPorts.has(port)) {
-        logger.warn(`Port ${port} is not published. Sending portclose.`);
+        logger.warn(() => `Port ${port} is not published. Sending portclose.`);
         this.rpc.portClose(ref);
         this.connection.deleteConnection(ref);
         return;
@@ -366,7 +385,7 @@ class PublishPort extends EventEmitter {
       const portConfig = this.publishedPorts.get(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.`);
+          logger.warn(() => `Device ${deviceId} is not whitelisted for port ${port}. Sending portclose.`);
           this.rpc.portClose(ref);
           this.connection.deleteConnection(ref);
           return;
@@ -398,9 +417,9 @@ class PublishPort extends EventEmitter {
     } else {
       const clientSocket = this.connection.getClientSocket(ref);
       if (clientSocket) {
-        logger.debug(`No local connection found for ref: ${ref.toString('hex')}, but client socket exists`);
+        logger.debug(() => `No local connection found for ref: ${ref.toString('hex')}, but client socket exists`);
       } else {
-        logger.warn(`No local connection found for ref ${ref.toString('hex')}. Sending portclose.`);
+        logger.warn(() => `No local connection found for ref ${ref.toString('hex')}. Sending portclose.`);
         this.rpc.sendError(sessionId, ref, 'No local connection found');
       }
     }
@@ -408,10 +427,10 @@ class PublishPort extends EventEmitter {
 
   handlePortClose(sessionIdRaw, messageContent) {
     const refRaw = messageContent[1];
-    const sessionId = Buffer.from(sessionIdRaw);
-    const ref = Buffer.from(refRaw);
+    const sessionId = toBufferView(sessionIdRaw);
+    const ref = toBufferView(refRaw);
 
-    logger.info(`Received portclose for ref ${ref.toString('hex')}`);
+    logger.info(() => `Received portclose for ref ${ref.toString('hex')}`);
 
     const connectionInfo = this.connection.getConnection(ref);
     if (connectionInfo) {

package/rpc.js

@@ -1,5 +1,5 @@
 //rpc.js
-const { makeReadable, parseRequestId, parseResponseType, parseReason } = require('./utils');
+const { makeReadable, parseRequestId, parseResponseType, parseReason, toBufferView } = require('./utils');
 const logger = require('./logger');
 
 class DiodeRPC {
@@ -17,7 +17,8 @@ class DiodeRPC {
           const blockNumberRaw = responseData[0];
           let blockNumber;
           if (blockNumberRaw instanceof Uint8Array) {
-            blockNumber = Buffer.from(blockNumberRaw).readUIntBE(0, blockNumberRaw.length);
+            const buf = toBufferView(blockNumberRaw);
+            blockNumber = buf.readUIntBE(0, buf.length);
           } else if (Buffer.isBuffer(blockNumberRaw)) {
             blockNumber = blockNumberRaw.readUIntBE(0, blockNumberRaw.length);
           } else if (typeof blockNumberRaw === 'number') {
@@ -25,10 +26,10 @@ class DiodeRPC {
           } else {
             throw new Error('Invalid block number format. response:', makeReadable(responseData));
           }
-          logger.debug(`Block number is: ${blockNumber}`);
+          logger.debug(() => `Block number is: ${blockNumber}`);
           return blockNumber;
         }).catch((error) => {
-          logger.error(`Error during get block peak: ${error}`);
+          logger.error(() => `Error during get block peak: ${error}`);
           return;
         });
       }
@@ -36,7 +37,7 @@ class DiodeRPC {
       return this.connection.sendCommand(['getblockheader', index]).then((responseData) => {
         return responseData[0]; // block_header
       }).catch((error) => {
-        logger.error(`Error during get block header: ${error}`);
+        logger.error(() => `Error during get block header: ${error}`);
         return;
       });
     }
@@ -45,7 +46,7 @@ class DiodeRPC {
       return this.connection.sendCommand(['getblock', index]).then((responseData) => {
         return responseData[0]; // block
       }).catch((error) => {
-        logger.error(`Error during get block: ${error}`);
+        logger.error(() => `Error during get block: ${error}`);
         return;
       });
     }
@@ -64,7 +65,7 @@ class DiodeRPC {
             throw new Error(`Unknown status in response: '${status}'`);
         }
         }).catch((error) => {
-          logger.error(`Error during ping: ${error}`);
+          logger.error(() => `Error during ping: ${error}`);
           return false;
         })
     }
@@ -82,7 +83,7 @@ class DiodeRPC {
           if (status === 'ok') {
             let ref = refOrReasonRaw;
             if (Buffer.isBuffer(ref) || ref instanceof Uint8Array) {
-              ref = Buffer.from(ref);
+              ref = toBufferView(ref);
             }
             return ref;
           } else if (status === 'error') {
@@ -92,7 +93,7 @@ class DiodeRPC {
             throw new Error(`Unknown status in response: '${status}'`);
           }
         }).catch((error) => {
-          logger.error(`Error during port open: ${error}`);
+          logger.error(() => `Error during port open: ${error}`);
           return;
         });
       }
@@ -108,7 +109,7 @@ class DiodeRPC {
         try {
           // If data is too large, split it into chunks
           if (data.length > MAX_CHUNK_SIZE) {
-            logger.debug(`Chunking large data of ${data.length} bytes into pieces of max ${MAX_CHUNK_SIZE} bytes`);
+            logger.debug(() => `Chunking large data of ${data.length} bytes into pieces of max ${MAX_CHUNK_SIZE} bytes`);
             let offset = 0;
             
             while (offset < data.length) {
@@ -144,7 +145,7 @@ class DiodeRPC {
             });
           }
         } catch (error) {
-          logger.error(`Error during port send: ${error}`);
+          logger.error(() => `Error during port send: ${error}`);
           throw error; // Rethrow to allow proper error handling upstream
         }
       }
@@ -165,21 +166,21 @@ class DiodeRPC {
             throw new Error(`Unknown status in response: '${status}'`);
           }
         }).catch((error) => {
-          logger.error(`Error during port close: ${error}`);
+          logger.error(() => `Error during port close: ${error}`);
           return;
         });
       }
 
       sendError(sessionId, ref, error) {
         return this.connection.sendCommandWithSessionId(['response', ref, 'error', error], sessionId).catch((error) => {
-          logger.error(`Error during send error: ${error}`);
+          logger.error(() => `Error during send error: ${error}`);
           return;
         });
       }
 
       sendResponse(sessionId, ref, response) {
         return this.connection.sendCommandWithSessionId(['response', ref, response], sessionId).catch((error) => {
-          logger.error(`Error during send response: ${error}`);
+          logger.error(() => `Error during send response: ${error}`);
           return;
         });
       }
@@ -187,10 +188,10 @@ class DiodeRPC {
       async getEpoch() {
         const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
         if (this.epochCache.expiry && this.epochCache.expiry > currentTime) {
-          logger.debug(`Using cached epoch: ${this.epochCache.epoch}`);
+          logger.debug(() => `Using cached epoch: ${this.epochCache.epoch}`);
           return this.epochCache.epoch;
         }
-        logger.debug(`Fetching new epoch. Expiry: ${this.epochCache.expiry}, Current time: ${currentTime}`);
+        logger.debug(() => `Fetching new epoch. Expiry: ${this.epochCache.expiry}, Current time: ${currentTime}`);
         const blockPeak = await this.getBlockPeak();
         const blockHeader = await this.getBlockHeader(blockPeak);
     
@@ -209,39 +210,34 @@ class DiodeRPC {
         return epoch;
       }
     
-      parseTimestamp(blockHeader) {        
-        // Search for the timestamp field by name
+      parseTimestamp(blockHeader) {
+        // Search for the timestamp field by name (robust to Buffer/Uint8Array)
         if (Array.isArray(blockHeader)) {
           for (const field of blockHeader) {
-            if (Array.isArray(field) && field.length >= 2 && field[0] === 'timestamp') {
-              const timestampValue = field[1];
-              
-              // Handle different timestamp value types
-              if (typeof timestampValue === 'number') {
-                return timestampValue;
-              } else if (typeof timestampValue === 'string' && timestampValue.startsWith('0x')) {
-                // Handle hex string
-                return parseInt(timestampValue.slice(2), 16);
-              } else if (typeof timestampValue === 'string') {
-                // Handle decimal string
-                return parseInt(timestampValue, 10);
-              } else if (timestampValue instanceof Uint8Array || Buffer.isBuffer(timestampValue)) {
-                // Handle buffer - carefully determine the byte length
-                const buf = Buffer.from(timestampValue);
-                // Use a safe approach to read the value based on buffer length
-                if (buf.length <= 6) {
-                  return buf.readUIntBE(0, buf.length);
-                } else {
-                  // For larger buffers, convert to hex string first
+            if (Array.isArray(field) && field.length >= 2) {
+              const key = typeof field[0] === 'string' ? field[0] : toBufferView(field[0]).toString('utf8');
+              if (key === 'timestamp') {
+                const timestampValue = field[1];
+                // Handle different timestamp value types
+                if (typeof timestampValue === 'number') {
+                  return timestampValue;
+                } else if (typeof timestampValue === 'string' && timestampValue.startsWith('0x')) {
+                  return parseInt(timestampValue.slice(2), 16);
+                } else if (typeof timestampValue === 'string') {
+                  return parseInt(timestampValue, 10);
+                } else if (timestampValue instanceof Uint8Array || Buffer.isBuffer(timestampValue)) {
+                  const buf = toBufferView(timestampValue);
+                  if (buf.length <= 6) {
+                    return buf.readUIntBE(0, buf.length);
+                  }
                   return parseInt(buf.toString('hex'), 16);
                 }
               }
             }
           }
         }
-        
-        // Fallback: if we couldn't find the timestamp or parse it correctly
-        logger.warn('Could not find or parse timestamp in block header, using current time');
+        // Fallback
+        logger.warn(() => 'Could not find or parse timestamp in block header, using current time');
         return Math.floor(Date.now() / 1000);
       }
   }

package/testServers/udpTest.js

@@ -15,11 +15,10 @@ server.on('message',function(msg,info){
 //sending msg
 server.send(msg,info.port,'localhost',function(error){
   if(error){
-    client.close();
+    server.close(); // was client.close();
   }else{
     console.log('Data sent !!!');
   }
-
 });
 
 });

package/utils.js

@@ -6,11 +6,20 @@ const { KEYUTIL } = require("jsrsasign");
 const fs = require('fs');
 var path = require('path');
 
+// Zero-copy view for Uint8Array -> Buffer where possible
+function toBufferView(u8) {
+  if (Buffer.isBuffer(u8)) return u8;
+  if (u8 && u8.buffer && typeof u8.byteOffset === 'number') {
+    return Buffer.from(u8.buffer, u8.byteOffset, u8.byteLength);
+  }
+  return Buffer.from(u8);
+}
+
 function makeReadable(decodedMessage) {
   if (Array.isArray(decodedMessage)) {
     return decodedMessage.map((item) => makeReadable(item));
   } else if (decodedMessage instanceof Uint8Array) {
-    const buffer = Buffer.from(decodedMessage);
+    const buffer = toBufferView(decodedMessage);
     // Try to interpret the Buffer as a UTF-8 string
     const str = buffer.toString('utf8');
     if (/^[\x20-\x7E]+$/.test(str)) {
@@ -42,7 +51,7 @@ function makeReadable(decodedMessage) {
 // Helper functions
 function parseRequestId(requestIdRaw) {
   if (requestIdRaw instanceof Uint8Array || Buffer.isBuffer(requestIdRaw)) {
-    const buffer = Buffer.from(requestIdRaw);
+    const buffer = toBufferView(requestIdRaw);
     return buffer.readUIntBE(0, buffer.length);
   } else if (typeof requestIdRaw === 'number') {
     return requestIdRaw;
@@ -53,10 +62,10 @@ function parseRequestId(requestIdRaw) {
 
 function parseResponseType(responseTypeRaw) {
   if (responseTypeRaw instanceof Uint8Array || Buffer.isBuffer(responseTypeRaw)) {
-    return Buffer.from(responseTypeRaw).toString('utf8');
+    return toBufferView(responseTypeRaw).toString('utf8');
   } else if (Array.isArray(responseTypeRaw)) {
     // Convert each element to Buffer and concatenate
-    const buffers = responseTypeRaw.map((item) => Buffer.from(item));
+    const buffers = responseTypeRaw.map((item) => toBufferView(item));
     const concatenated = Buffer.concat(buffers);
     return concatenated.toString('utf8');
   } else if (typeof responseTypeRaw === 'string') {
@@ -68,7 +77,7 @@ function parseResponseType(responseTypeRaw) {
 
 function parseReason(reasonRaw) {
   if (Buffer.isBuffer(reasonRaw) || reasonRaw instanceof Uint8Array) {
-    return Buffer.from(reasonRaw).toString('utf8');
+    return toBufferView(reasonRaw).toString('utf8');
   } else if (typeof reasonRaw === 'string') {
     return reasonRaw;
   } else {
@@ -128,7 +137,7 @@ function loadOrGenerateKeyPair(keyLocation) {
     
     // Try to load existing keys
     if (fs.existsSync(keyLocation)) {
-      logger.info(`Loading keys from ${keyLocation}`);
+      logger.info(() => `Loading keys from ${keyLocation}`);
       const keyData = JSON.parse(fs.readFileSync(keyLocation, 'utf8'));
       
       // Convert the stored JSON back to keypair objects
@@ -138,7 +147,7 @@ function loadOrGenerateKeyPair(keyLocation) {
       return { prvKeyObj, pubKeyObj };
     } else {
       // Generate new keypair
-      logger.info(`Generating new key pair at ${keyLocation}`);
+      logger.info(() => `Generating new key pair at ${keyLocation}`);
       const kp = KEYUTIL.generateKeypair("EC", "secp256k1");
       
       // Store the keys in a serializable format
@@ -154,7 +163,7 @@ function loadOrGenerateKeyPair(keyLocation) {
       return kp;
     }
   } catch (error) {
-    logger.error(`Error loading or generating key pair: ${error}`);
+    logger.error(() => `Error loading or generating key pair: ${error}`);
     throw error;
   }
 }
@@ -175,5 +184,6 @@ module.exports = {
   parseReason, 
   generateCert, 
   loadOrGenerateKeyPair,
-  ensureDirectoryExistence 
+  ensureDirectoryExistence,
+  toBufferView,
 };