diodejs 0.2.2 → 0.4.0

package/rpc.js

@@ -1,7 +1,86 @@
 //rpc.js
-const { makeReadable, parseRequestId, parseResponseType, parseReason } = require('./utils');
+const { makeReadable, parseRequestId, parseResponseType, parseReason, parseUInt, toBufferView } = require('./utils');
 const logger = require('./logger');
 
+function decodeToken(value) {
+    if (typeof value === 'string') return value;
+    if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+      return toBufferView(value).toString('utf8');
+    }
+    return '';
+}
+
+function normalizeAddressParam(value) {
+    if (!value) return value;
+    if (Buffer.isBuffer(value)) return value;
+    if (value instanceof Uint8Array) return toBufferView(value);
+    if (typeof value === 'string') {
+      const hex = value.toLowerCase().startsWith('0x') ? value.slice(2) : value;
+      if (!hex) return Buffer.alloc(0);
+      return Buffer.from(hex, 'hex');
+    }
+    return value;
+}
+
+function parseDeviceTicketObject(obj) {
+    if (!Array.isArray(obj) || obj.length < 2) {
+      return null;
+    }
+    const objectType = decodeToken(obj[0]);
+    if (objectType !== 'ticket' && objectType !== 'ticketv2') {
+      return null;
+    }
+    const serverIdRaw = obj[1];
+    let serverId = null;
+    if (Buffer.isBuffer(serverIdRaw) || serverIdRaw instanceof Uint8Array) {
+      serverId = toBufferView(serverIdRaw);
+    } else if (typeof serverIdRaw === 'string') {
+      const hex = serverIdRaw.toLowerCase().startsWith('0x') ? serverIdRaw.slice(2) : serverIdRaw;
+      if (hex && /^[0-9a-f]+$/.test(hex)) {
+        serverId = Buffer.from(hex, 'hex');
+      }
+    }
+    const serverIdHex = serverId ? `0x${serverId.toString('hex')}` : '';
+
+    const ticket = {
+      objectType,
+      serverId,
+      serverIdHex,
+    };
+
+    if (objectType === 'ticketv2') {
+      ticket.chainId = parseUInt(obj[2]);
+      ticket.epoch = parseUInt(obj[3]);
+    } else {
+      ticket.blockNumber = parseUInt(obj[2]);
+    }
+
+    return ticket;
+}
+
+function parseServerObject(obj) {
+    if (!Array.isArray(obj) || obj.length < 4) {
+      return null;
+    }
+    const type = decodeToken(obj[0]);
+    if (type !== 'server') {
+      return null;
+    }
+
+    const hostRaw = obj[1];
+    const host = (Buffer.isBuffer(hostRaw) || hostRaw instanceof Uint8Array)
+      ? toBufferView(hostRaw).toString('utf8')
+      : (typeof hostRaw === 'string' ? hostRaw : '');
+    const edgePort = parseUInt(obj[2]);
+    const serverPort = parseUInt(obj[3]);
+
+    return {
+      host,
+      edgePort,
+      serverPort,
+    };
+}
+
 class DiodeRPC {
     constructor(connection) {
       this.connection = connection;
@@ -17,7 +96,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 +105,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 +116,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 +125,31 @@ 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;
+      });
+    }
+
+    getObject(deviceId) {
+      const normalized = normalizeAddressParam(deviceId);
+      return this.connection.sendCommand(['getobject', normalized]).then((responseData) => {
+        const obj = responseData[0];
+        const parsed = parseDeviceTicketObject(obj);
+        return parsed || obj;
+      }).catch((error) => {
+        logger.error(() => `Error during get object: ${error}`);
+        return;
+      });
+    }
+
+    getNode(nodeId) {
+      const normalized = normalizeAddressParam(nodeId);
+      return this.connection.sendCommand(['getnode', normalized]).then((responseData) => {
+        const obj = responseData[0];
+        const parsed = parseServerObject(obj);
+        return parsed || obj;
+      }).catch((error) => {
+        logger.error(() => `Error during get node: ${error}`);
         return;
       });
     }
@@ -64,7 +168,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 +186,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 +196,28 @@ 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;
+        });
+      }
+
+      portOpen2(deviceId, port, flags = 'rw') {
+        return this.connection.sendCommand(['portopen2', deviceId, port, flags]).then((responseData) => {
+          // responseData is [status, physicalPortOrReason]
+          const [statusRaw, portOrReasonRaw] = responseData;
+          const status = parseResponseType(statusRaw);
+  
+          if (status === 'ok') {
+            const physicalPort = parseUInt(portOrReasonRaw);
+            return physicalPort !== null ? physicalPort : portOrReasonRaw;
+          } else if (status === 'error') {
+            const reason = parseReason(portOrReasonRaw);
+            throw new Error(reason);
+          } else {
+            throw new Error(`Unknown status in response: '${status}'`);
+          }
+        }).catch((error) => {
+          logger.error(() => `Error during port open2: ${error}`);
           return;
         });
       }
@@ -108,7 +233,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 +269,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 +290,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 +312,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 +334,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 {
@@ -76,6 +85,28 @@ function parseReason(reasonRaw) {
   }
 }
 
+function parseUInt(valueRaw) {
+  if (valueRaw === null || valueRaw === undefined) {
+    return null;
+  }
+  if (typeof valueRaw === 'number') {
+    return valueRaw;
+  }
+  if (typeof valueRaw === 'string') {
+    if (valueRaw.startsWith('0x')) {
+      return parseInt(valueRaw.slice(2), 16);
+    }
+    const parsed = Number(valueRaw);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  if (Buffer.isBuffer(valueRaw) || valueRaw instanceof Uint8Array) {
+    const buffer = toBufferView(valueRaw);
+    if (buffer.length === 0) return 0;
+    return buffer.readUIntBE(0, buffer.length);
+  }
+  return null;
+}
+
 function generateCert(privateKeyObj, publicKeyObj) {
   // Generate a certificate valid for 1 month
   function formatDate(date) {
@@ -128,7 +159,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 +169,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 +185,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;
   }
 }
@@ -173,7 +204,9 @@ module.exports = {
   parseRequestId, 
   parseResponseType, 
   parseReason, 
+  parseUInt,
   generateCert, 
   loadOrGenerateKeyPair,
-  ensureDirectoryExistence 
+  ensureDirectoryExistence,
+  toBufferView,
 };