diodejs 0.0.3 → 0.0.5

package/README.md

@@ -1,20 +1,19 @@
-# diode_js
+# DiodeJs
 
 ## Overview
-`diode_js` is a JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.
+`diodejs` is a JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.
 
 ## Installation
 ```bash
 npm install diodejs
 ```
-## Quick Start
 
-To get started, you need to generate a device certificate using OpenSSL. You can use this command:
+### Quick Start
 
-```bash
-openssl ecparam -name secp256k1 -out secp256k1_params.pem
-openssl req -newkey ec:./secp256k1_params.pem -nodes -keyout device_certificate.pem -x509 -days 365 -out device_certificate.pem -subj "/CN=device"
-```
+If you want to enable logs, set environment variable LOG to true. 
+If you want to enable debug logs, set environment variable DEBUG to true. 
+
+Can also use .env files
 
 ### Test RPC
 
@@ -96,3 +95,65 @@ async function main() {
 main();
 
 ```
+
+## Reference
+
+### Classes and Methods
+
+#### `DiodeConnection`
+
+- **Constructor**: `new DiodeConnection(host, port, certPath)`
+  - `host` (string): The host address of the Diode server.
+  - `port` (number): The port number of the Diode server.
+  - `certPath` (string)(default: ./cert/device_certificate.pem): The path to the device certificate. If doesn't exist, generates automaticly. 
+
+- **Methods**:
+  - `connect()`: Connects to the Diode server. Returns a promise.
+  - `sendCommand(commandArray)`: Sends a command to the Diode server. Returns a promise.
+  - `sendCommandWithSessionId(commandArray, sessionId)`: Sends a command with a session ID. Returns a promise.
+  - `getEthereumAddress()`: Returns the Ethereum address derived from the device certificate.
+  - `getServerEthereumAddress()`: Returns the Ethereum address of the server.
+  - `createTicketCommand()`: Creates a ticket command for authentication. Returns a promise.
+  - `close()`: Closes the connection to the Diode server.
+
+#### `DiodeRPC`
+
+- **Constructor**: `new DiodeRPC(connection)`
+  - `connection` (DiodeConnection): An instance of `DiodeConnection`.
+
+- **Methods**:
+  - `getBlockPeak()`: Retrieves the current block peak. Returns a promise.
+  - `getBlockHeader(index)`: Retrieves the block header for a given index. Returns a promise.
+  - `getBlock(index)`: Retrieves the block for a given index. Returns a promise.
+  - `ping()`: Sends a ping command. Returns a promise.
+  - `portOpen(deviceId, port, flags)`: Opens a port on the device. Returns a promise.
+  - `portSend(ref, data)`: Sends data to the device. Returns a promise.
+  - `portClose(ref)`: Closes a port on the device. Returns a promise.
+  - `sendError(sessionId, ref, error)`: Sends an error response. Returns a promise.
+  - `sendResponse(sessionId, ref, response)`: Sends a response. Returns a promise.
+  - `getEpoch()`: Retrieves the current epoch. Returns a promise.
+  - `parseTimestamp(blockHeader)`: Parses the timestamp from a block header. Returns a number.
+
+#### `BindPort`
+
+- **Constructor**: `new BindPort(connection, localPort, targetPort, deviceIdHex)`
+  - `connection` (DiodeConnection): An instance of `DiodeConnection`.
+  - `localPort` (number): The local port to bind.
+  - `targetPort` (number): The target port on the device.
+  - `deviceIdHex` (string): The device ID in hexadecimal format.
+
+- **Methods**:
+  - `bind()`: Binds the local port to the target port on the device.
+
+#### `PublishPort`
+
+- **Constructor**: `new PublishPort(connection, publishedPorts, certPath)`
+  - `connection` (DiodeConnection): An instance of `DiodeConnection`.
+  - `publishedPorts` (array): An array of ports to publish.
+  - `certPath` (string): The path to the device certificate.
+
+- **Methods**:
+  - `startListening()`: Starts listening for unsolicited messages.
+  - `handlePortOpen(sessionIdRaw, messageContent)`: Handles port open requests.
+  - `handlePortSend(sessionIdRaw, messageContent)`: Handles port send requests.
+  - `handlePortClose(sessionIdRaw, messageContent)`: Handles port close requests.

package/bindPort.js

@@ -1,6 +1,7 @@
 const net = require('net');
 const { Buffer } = require('buffer');
 const DiodeRPC = require('./rpc');
+const logger = require('./logger');
 
 class BindPort {
   constructor(connection, localPort, targetPort,deviceIdHex) {
@@ -35,7 +36,7 @@ class BindPort {
         if (clientSocket) {
           clientSocket.write(data);
         } else {
-          console.warn(`No client socket found for ref: ${dataRef.toString('hex')}`);
+          logger.warn(`No client socket found for ref: ${dataRef.toString('hex')}`);
         }
       } else if (messageType === 'portclose') {
         const refRaw = messageContent[1];
@@ -47,24 +48,30 @@ class BindPort {
         if (clientSocket) {
           clientSocket.end();
           clientSockets.delete(dataRef.toString('hex'));
-          console.log(`Port closed for ref: ${dataRef.toString('hex')}`);
+          logger.info(`Port closed for ref: ${dataRef.toString('hex')}`);
         }
       } else {
-        console.warn(`Unknown unsolicited message type: ${messageType}`);
+        logger.warn(`Unknown unsolicited message type: ${messageType}`);
       }
     });
 
     // Set up local server
     const server = net.createServer(async (clientSocket) => {
-      console.log('Client connected to local server');
+      logger.info('Client connected to local server');
 
       // Open a new port on the device for this client
       let ref;
       try {
         ref = await rpc.portOpen(deviceId, this.targetPort, 'rw');
-        console.log(`Port opened on device with ref: ${ref.toString('hex')} for client`);
+        if (!ref) {
+          logger.error('Error opening port on device');
+          clientSocket.destroy();
+          return
+        } else {
+          logger.info(`Port opened on device with ref: ${ref.toString('hex')} for client`);
+        }
       } catch (error) {
-        console.error('Error opening port on device:', error);
+        logger.error(`Error opening port on device: ${error}`);
         clientSocket.destroy();
         return;
       }
@@ -77,41 +84,46 @@ class BindPort {
         try {
           await rpc.portSend(ref, data);
         } catch (error) {
-          console.error('Error sending data to device:', error);
+          logger.error(`Error sending data to device: ${error}`);
           clientSocket.destroy();
         }
       });
 
       // Handle client socket closure
       clientSocket.on('end', async () => {
-        console.log('Client disconnected');
-        clientSockets.delete(ref.toString('hex'));
-        try {
-          console.log(`Port closed on device for ref: ${ref.toString('hex')}`);
-        } catch (error) {
-          console.error('Error closing port on device:', error);
+        logger.info('Client disconnected');
+        if (ref && clientSockets.has(ref.toString('hex'))) {
+          try {
+            await rpc.portClose(ref);
+            logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
+            clientSockets.delete(ref.toString('hex'));
+          } catch (error) {
+            logger.error(`Error closing port on device: ${error}`);
+          }
+        } else {
+          logger.warn('Ref is invalid or no longer in clientSockets.');
         }
       });
 
       // Handle client socket errors
       clientSocket.on('error', (err) => {
-        console.error('Client socket error:', err);
+        logger.error('Client socket error:', err);
       });
     });
 
     server.listen(this.localPort, () => {
-      console.log(`Local server listening on port ${this.localPort}`);
+      logger.info(`Local server listening on port ${this.localPort}`);
     });
 
     // Handle device disconnect
     this.connection.on('end', () => {
-      console.log('Disconnected from Diode.io server');
+      logger.info('Disconnected from Diode.io server');
       server.close();
     });
 
     // Handle connection errors
     this.connection.on('error', (err) => {
-      console.error('Connection error:', err);
+      logger.error(`Connection error: ${err}`);
       server.close();
     });
   }

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 } = require('./utils');
+const { makeReadable, parseRequestId, parseResponseType, parseReason, generateCert } = require('./utils');
 const { Buffer } = require('buffer'); // Import Buffer
 const asn1 = require('asn1.js');
 const secp256k1 = require('secp256k1');
@@ -11,8 +11,9 @@ const ethUtil = require('ethereumjs-util');
 const crypto = require('crypto');
 const DiodeRPC = require('./rpc');
 const abi = require('ethereumjs-abi');
+const logger = require('./logger');
 class DiodeConnection extends EventEmitter {
-  constructor(host, port, certPath) {
+  constructor(host, port, certPath = './cert/device_certificate.pem') {
     super();
     this.host = host;
     this.port = port;
@@ -25,6 +26,13 @@ class DiodeConnection extends EventEmitter {
     // Add buffer to handle partial data
     this.receiveBuffer = Buffer.alloc(0);
     this.RPC = new DiodeRPC(this);
+    this.isReconnecting = false;
+    this.connectPromise = null;
+
+    // Check if certPath exists, if not generate the certificate
+    if (!fs.existsSync(this.certPath)) {
+      generateCert(this.certPath);
+    }
   }
 
   connect() {
@@ -40,41 +48,63 @@ class DiodeConnection extends EventEmitter {
       };
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
-        console.log('Connected to Diode.io server');
+        logger.info('Connected to Diode.io server');
         // Set keep-alive to prevent connection timeout forever
         this.socket.setKeepAlive(true, 0);
   
         // Send the ticketv2 command
         try {
           const ticketCommand = await this.createTicketCommand();
-          const response = await this.sendCommand(ticketCommand);
-          console.log('Ticket accepted:', response);
+          const response = await this.sendCommand(ticketCommand).catch(reject);
+          logger.info(`Ticket accepted: ${makeReadable(response)}`);
           resolve();
         } catch (error) {
-          console.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')}`);
         try {
           this._handleData(data);
         } catch (error) {
-          console.error('Error handling data:', error);
+          logger.error(`Error handling data: ${error}`);
         }
       });
       this.socket.on('error', (err) => {
-        console.error('Connection error:', err);
+        logger.error(`Connection error: ${err}`);
         reject(err);
       });
-      this.socket.on('end', () => console.log('Disconnected from server'));
+      this.socket.on('end', () => logger.info('Disconnected from server'));
     });
   }
 
+  _ensureConnected() {
+    if (this.socket && !this.socket.destroyed) {
+      return Promise.resolve();
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.isReconnecting = true;
+    this.connectPromise = this.connect()
+      .then(() => {
+        this.isReconnecting = false;
+        this.connectPromise = null;
+      })
+      .catch((err) => {
+        this.isReconnecting = false;
+        this.connectPromise = null;
+        throw err;
+      });
+    return this.connectPromise;
+  }
+
   _handleData(data) {
     // Append new data to the receive buffer
     this.receiveBuffer = Buffer.concat([this.receiveBuffer, data]);
-    console.log('Received data:', data.toString('hex'));
+    logger.debug(`Received data: ${data.toString('hex')}`);
   
     let offset = 0;
     while (offset + 2 <= this.receiveBuffer.length) {
@@ -92,7 +122,7 @@ class DiodeConnection extends EventEmitter {
   
       try {
         const decodedMessage = RLP.decode(Uint8Array.from(messageBuffer));
-        console.log('Decoded message:', makeReadable(decodedMessage));
+        logger.debug(`Decoded message: ${makeReadable(decodedMessage)}`);
     
         if (Array.isArray(decodedMessage) && decodedMessage.length > 1) {
           const requestIdRaw = decodedMessage[0];
@@ -102,8 +132,8 @@ class DiodeConnection extends EventEmitter {
           const requestId = parseRequestId(requestIdRaw);
     
           // Debug statements
-          console.log('requestIdRaw:', requestIdRaw);
-          console.log('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
@@ -111,16 +141,14 @@ class DiodeConnection extends EventEmitter {
             const responseRaw = responseData[0];
     
             // Debug statements
-            console.log('responseTypeRaw:', responseTypeRaw);
-            console.log('Type of responseTypeRaw:', typeof responseTypeRaw);
-            console.log('Instance of responseTypeRaw:', responseTypeRaw instanceof Uint8Array);
-            console.log('Is Array:', Array.isArray(responseTypeRaw));
+            logger.debug(`responseTypeRaw: ${responseTypeRaw}`);
+            logger.debug(`Type of responseTypeRaw: ${typeof responseTypeRaw}`);
     
             // Parse responseType
             const responseType = parseResponseType(responseTypeRaw);
     
-            console.log(`Received response for requestId: ${requestId}`);
-            console.log(`Response Type: '${responseType}'`);
+            logger.debug(`Received response for requestId: ${requestId}`);
+            logger.debug(`Response Type: '${responseType}'`);
     
             const { resolve, reject } = this.pendingRequests.get(requestId);
             try{
@@ -137,29 +165,29 @@ class DiodeConnection extends EventEmitter {
               } else if (responseType === 'error') {
                 if (responseData.length > 1) {
                   const reason = parseReason(responseData[1]);
-                  reject(new Error(reason));
+                  reject(reason);
                 } else {
                   const reason = parseReason(responseData[0]);
-                  reject(new Error(reason));
+                  reject(reason);
                 }
               } else {
                 resolve(responseData);
               }
             } catch (error) {
-              console.error('Error handling response:', error);
+              logger.error(`Error handling response: ${error}`);
             }
             this.pendingRequests.delete(requestId);
           } else {
             // This is an unsolicited message
-            console.log('Received unsolicited message:', decodedMessage);
+            logger.debug(`Received unsolicited message: ${makeReadable(decodedMessage)}`);
             this.emit('unsolicited', decodedMessage);
           }
         } else {
           // Invalid message format
-          console.error('Invalid message format:', decodedMessage);
+          logger.error(`Invalid message format: ${makeReadable(decodedMessage)}`);
         }
       } catch (error) {
-        console.error('Error decoding message:', error);
+        logger.error(`Error decoding message: ${error}`);
       }
     }
     
@@ -190,67 +218,55 @@ class DiodeConnection extends EventEmitter {
 
   sendCommand(commandArray) {
     return new Promise((resolve, reject) => {
-      //check if connection is alive
-      if (!this.socket || this.socket.destroyed) {
-        //reconnect
-        this.connect().then(() => {
-          this.sendCommand(commandArray).then(resolve).catch(reject);
-        }).catch(reject);
-        return;
-      }
-      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);
-
-      // Create a 2-byte length buffer
-      const lengthBuffer = Buffer.alloc(2);
-      lengthBuffer.writeUInt16BE(byteLength, 0);
-
-      const message = Buffer.concat([lengthBuffer, commandBuffer]);
-
-      console.log(`Sending command with requestId ${requestId}:`, commandArray);
-      console.log('Command buffer:', message.toString('hex'));
-
-      this.socket.write(message);
+      this._ensureConnected().then(() => {
+        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);
+  
+        // 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')}`);
+  
+        this.socket.write(message);
+      }).catch(reject);
     });
   }
 
   sendCommandWithSessionId(commandArray, sessionId) {
     return new Promise((resolve, reject) => {
-      //check if connection is alive
-      if (!this.socket || this.socket.destroyed) {
-        //reconnect
-        this.connect().then(() => {
-          this.sendCommand(commandArray).then(resolve).catch(reject);
-        }).catch(reject);
-        return;
-      }
-      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);
-
-      // Create a 2-byte length buffer
-      const lengthBuffer = Buffer.alloc(2);
-      lengthBuffer.writeUInt16BE(byteLength, 0);
-
-      const message = Buffer.concat([lengthBuffer, commandBuffer]);
-
-      console.log(`Sending command with requestId ${requestId}:`, commandArray);
-      console.log('Command buffer:', message.toString('hex'));
-
-      this.socket.write(message);
+      this._ensureConnected().then(() => {
+        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);
+  
+        // 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')}`);
+  
+        this.socket.write(message);
+      }).catch(reject);
     });
   }
 
@@ -300,7 +316,7 @@ class DiodeConnection extends EventEmitter {
 
         const ecPrivateKey = ECPrivateKeyASN.decode(privateKeyOctetString, 'der');
         privateKeyBytes = ecPrivateKey.privateKey;
-        console.log('Private key bytes:', privateKeyBytes.toString('hex'));
+        logger.debug(`Private key bytes: ${privateKeyBytes.toString('hex')}`);
       } else {
         throw new Error('Unsupported key format. Expected EC PRIVATE KEY or PRIVATE KEY in PEM format.');
       }
@@ -317,10 +333,10 @@ class DiodeConnection extends EventEmitter {
       const addressBuffer = ethUtil.pubToAddress(publicKeyBuffer, true);
       const address = '0x' + addressBuffer.toString('hex');
 
-      console.log('Ethereum address:', address);
+      logger.info(`Ethereum address: ${address}`);
       return address;
     } catch (error) {
-      console.error('Error extracting Ethereum address:', error);
+      logger.error(`Error extracting Ethereum address: ${error}`);
       throw error;
     }
   }
@@ -336,15 +352,15 @@ class DiodeConnection extends EventEmitter {
         ? serverCert.pubkey
         : Buffer.from(serverCert.pubkey);
 
-      console.log('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');
 
-      console.log('Server Ethereum address:', address);
+      logger.info(`Server Ethereum address: ${address}`);
       return address;
     } catch (error) {
-      console.error('Error extracting server Ethereum address:', error);
+      logger.error(`Error extracting server Ethereum address: ${error}`);
       throw error;
     }
   }
@@ -448,7 +464,7 @@ class DiodeConnection extends EventEmitter {
 
       return privateKeyBytes;
     } catch (error) {
-      console.error('Error extracting Ethereum address:', error);
+      logger.error(`Error extracting Ethereum address: ${error}`);
       throw error;
     }
   }
@@ -475,17 +491,17 @@ class DiodeConnection extends EventEmitter {
     // Convert each element in dataToSign to bytes32 and concatenate them
     const encodedData = Buffer.concat(dataToSign.map(item => abi.rawEncode(['bytes32'], [item])));
 
-    console.log('Encoded data:', encodedData.toString('hex'));
+    logger.debug(`Encoded data: ${encodedData.toString('hex')}`);
 
-    console.log('Data to sign:', makeReadable(dataToSign));
+    logger.debug(`Data to sign: ${makeReadable(dataToSign)}`);
   
   
     // Sign the data
     const privateKey = this.getPrivateKey();
     const msgHash = ethUtil.keccak256(encodedData);
-    console.log('Message hash:', msgHash.toString('hex'));
+    logger.debug(`Message hash: ${msgHash.toString('hex')}`);
     const signature = secp256k1.ecdsaSign(msgHash, privateKey);
-    console.log('Signature:', signature);
+    logger.debug(`Signature: ${signature.signature.toString('hex')}`);
     
     const signatureBuffer = Buffer.concat([
       ethUtil.toBuffer([signature.recid]),
@@ -519,7 +535,7 @@ class DiodeConnection extends EventEmitter {
       localAddress,
       epoch
     );
-    console.log('Signature hex:', signature.toString('hex'));
+    logger.debug(`Signature hex: ${signature.toString('hex')}`);
 
   
     // Construct the ticket command

package/examples/portForwardTest.js

@@ -8,7 +8,7 @@ async function main() {
     const connection = new DiodeConnection(host, port, certPath);
     await connection.connect();
   
-    const portForward = new BindPort(connection, 3002, 80, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    const portForward = new BindPort(connection, 3002, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
     portForward.bind();
     
 }

package/index.js

@@ -4,4 +4,5 @@ const DiodeRPC = require('./rpc');
 const BindPort = require('./bindPort');
 const PublishPort = require('./publishPort');
 const makeReadable = require('./utils').makeReadable;
-module.exports = { DiodeConnection, DiodeRPC, BindPort , PublishPort, makeReadable };
+const logger = require('./logger');
+module.exports = { DiodeConnection, DiodeRPC, BindPort , PublishPort, makeReadable, logger };

package/logger.js

@@ -0,0 +1,28 @@
+const setupLogger = require('dera-logger');
+require('dotenv').config();
+const isDebug = (process.env.DEBUG === 'true'); // Simple debug flag
+const isLogEnabled = (process.env.LOG === 'true'); // Simple log flag
+
+const options = {
+  logDirectory: 'logs',
+  timestampFormat: 'HH:mm:ss',
+  fileDatePattern: 'YYYY-MM-DD',
+  zippedArchive: false,
+  maxLogFileSize: null,
+  maxFiles: '14d',
+  addConsoleInNonProduction: true,
+  transports: [
+    { filename: 'combined', level: 'silly', source: 'app' },
+    { filename: 'error', level: 'warn', source: 'app' }
+  ]
+};
+
+const logger = setupLogger(options);
+
+// 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'); },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "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,18 +11,20 @@
   "dependencies": {
     "@ethereumjs/rlp": "^5.0.2",
     "asn1.js": "^5.4.1",
-    "axios": "^1.6.8",
     "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",
     "node-fetch": "^2.7.0",
     "rlp": "^3.0.0",
-    "secp256k1": "^5.0.0",
+    "secp256k1": "^5.0.1",
     "tls": "^0.0.1"
   }
 }

package/publishPort.js

@@ -8,6 +8,8 @@ const { Buffer } = require('buffer');
 const EventEmitter = require('events');
 const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
+const { makeReadable } = require('./utils');
+const logger = require('./logger');
 
 class DiodeSocket extends Duplex {
   constructor(ref, rpc) {
@@ -37,7 +39,7 @@ class PublishPort extends EventEmitter {
   constructor(connection, publishedPorts, certPath) {
     super();
     this.connection = connection;
-    this.publishedPorts = publishedPorts; // Array of ports to publish
+    this.publishedPorts = new Set(publishedPorts); // Convert array to a Set
     this.connections = new Map(); // Map to store active connections
     this.startListening();
     this.rpc = new DiodeRPC(connection);
@@ -58,7 +60,7 @@ class PublishPort extends EventEmitter {
       } else if (messageType === 'portclose') {
         this.handlePortClose(sessionIdRaw, messageContent);
       } else {
-        console.warn(`Unknown unsolicited message type: ${messageType}`);
+        logger.warn(`Unknown unsolicited message type: ${messageType}`);
       }
     });
   }
@@ -70,19 +72,30 @@ class PublishPort extends EventEmitter {
     const deviceIdRaw = messageContent[3];
 
     const sessionId = Buffer.from(sessionIdRaw);
-    const portString = Buffer.from(portStringRaw).toString('utf8');
+    const portString = makeReadable(portStringRaw);
     const ref = Buffer.from(refRaw);
     const deviceId = Buffer.from(deviceIdRaw).toString('hex');
 
-    console.log(`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
-    const [protocol, portStr] = portString.split(':');
-    const port = parseInt(portStr, 10);
+    var protocol = 'tcp';
+    var port = 0;
+    if (typeof portString == 'number') {
+      port = portString;
+    } else {
+      var [protocol, portStr] = portString.split(':');
+      console.log(`Protocol: ${protocol}, Port: ${portStr}`);
+      if (!portStr) {
+        portStr = protocol;
+        protocol = 'tcp';
+      }
+      port = parseInt(portStr, 10);
+    }
 
     // Check if the port is published
-    if (!this.publishedPorts.includes(port)) {
-      console.warn(`Port ${port} is not published. Rejecting request.`);
+    if (!this.publishedPorts.has(port)) { // Use .has() instead of .includes()
+      logger.warn(`Port ${port} is not published. Rejecting request.`);
       // Send error response
       this.rpc.sendError(sessionId, ref, 'Port is not published');
       return;
@@ -96,7 +109,7 @@ class PublishPort extends EventEmitter {
     } else if (protocol === 'udp') {
       this.handleUDPConnection(sessionId, ref, port);
     } else {
-      console.warn(`Unsupported protocol: ${protocol}`);
+      logger.warn(`Unsupported protocol: ${protocol}`);
       this.rpc.sendError(sessionId, ref, `Unsupported protocol: ${protocol}`);
     }
   }
@@ -111,14 +124,14 @@ class PublishPort extends EventEmitter {
       });
 
       localSocket.on('end', () => {
-        console.log(`Local service disconnected`);
+        logger.info(`Local service disconnected`);
         // Send portclose message to Diode
         this.rpc.portClose(ref);
         this.connections.delete(ref.toString('hex'));
       });
 
       localSocket.on('error', (err) => {
-        console.error(`Error with local service:`, err);
+        logger.error(`Error with local service: ${err}`);
         // Send portclose message to Diode
         this.rpc.portClose(ref);
         this.connections.delete(ref.toString('hex'));
@@ -129,7 +142,7 @@ class PublishPort extends EventEmitter {
   handleTCPConnection(sessionId, ref, port) {
     // Create a TCP connection to the local service on the specified port
     const localSocket = net.connect({ port: port }, () => {
-      console.log(`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');
     });
@@ -164,7 +177,7 @@ class PublishPort extends EventEmitter {
 
     // Connect to the local service (TCP or TLS as needed)
     const localSocket = net.connect({ port: port }, () => {
-      console.log(`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');
     });
@@ -174,7 +187,7 @@ class PublishPort extends EventEmitter {
 
     // Handle errors and cleanup
     tlsSocket.on('error', (err) => {
-      console.error('TLS Socket error:', err);
+      logger.error(`TLS Socket error: ${err}`);
       this.rpc.portClose(ref);
       this.connections.delete(ref.toString('hex'));
     });
@@ -210,6 +223,8 @@ class PublishPort extends EventEmitter {
       remoteInfo,
     });
 
+    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
@@ -221,7 +236,7 @@ class PublishPort extends EventEmitter {
     });
 
     localSocket.on('error', (err) => {
-      console.error(`UDP Socket error:`, err);
+      logger.error(`UDP Socket error: ${err}`);
       this.rpc.portClose(ref);
       this.connections.delete(ref.toString('hex'));
     });
@@ -233,7 +248,7 @@ class PublishPort extends EventEmitter {
 
     const sessionId = Buffer.from(sessionIdRaw);
     const ref = Buffer.from(refRaw);
-    const data = Buffer.from(dataRaw).slice(4);
+    const data = Buffer.from(dataRaw)//.slice(4);
 
     const connectionInfo = this.connections.get(ref.toString('hex'));
     if (connectionInfo) {
@@ -262,7 +277,7 @@ class PublishPort extends EventEmitter {
         diodeSocket.pushData(data);
       }
     } else {
-      console.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');
     }
   }
@@ -272,7 +287,7 @@ class PublishPort extends EventEmitter {
     const sessionId = Buffer.from(sessionIdRaw);
     const ref = Buffer.from(refRaw);
 
-    console.log(`Received portclose for ref ${ref.toString('hex')}`);
+    logger.info(`Received portclose for ref ${ref.toString('hex')}`);
 
     const connectionInfo = this.connections.get(ref.toString('hex'));
     if (connectionInfo) {

package/rpc.js

@@ -1,5 +1,6 @@
 //rpc.js
 const { makeReadable, parseRequestId, parseResponseType, parseReason } = require('./utils');
+const logger = require('./logger');
 
 class DiodeRPC {
     constructor(connection) {
@@ -24,36 +25,49 @@ class DiodeRPC {
           } else {
             throw new Error('Invalid block number format. response:', makeReadable(responseData));
           }
+          logger.debug(`Block number is: ${blockNumber}`);
           return blockNumber;
+        }).catch((error) => {
+          logger.error(`Error during get block peak: ${error}`);
+          return;
         });
       }
     getBlockHeader(index) {
       return this.connection.sendCommand(['getblockheader', index]).then((responseData) => {
         return responseData[0]; // block_header
+      }).catch((error) => {
+        logger.error(`Error during get block header: ${error}`);
+        return;
       });
     }
   
     getBlock(index) {
       return this.connection.sendCommand(['getblock', index]).then((responseData) => {
         return responseData[0]; // block
+      }).catch((error) => {
+        logger.error(`Error during get block: ${error}`);
+        return;
       });
     }
   
     ping() {
-        return this.connection.sendCommand(['ping']).then((responseData) => {
-            // responseData is an array containing [status]
-            const statusRaw = responseData[0];
-            const status = parseResponseType(statusRaw);
-        
-            if (status === 'pong') {
-                return true;
-            } else if (status === 'error') {
-                throw new Error('Ping failed');
-            } else {
-                throw new Error(`Unknown status in response: '${status}'`);
-            }
-            });
+      return this.connection.sendCommand(['ping']).then((responseData) => {
+        // responseData is an array containing [status]
+        const statusRaw = responseData[0];
+        const status = parseResponseType(statusRaw);
+    
+        if (status === 'pong') {
+            return true;
+        } else if (status === 'error') {
+            throw new Error('Ping failed');
+        } else {
+            throw new Error(`Unknown status in response: '${status}'`);
         }
+        }).catch((error) => {
+          logger.error(`Error during ping: ${error}`);
+          return false;
+        })
+    }
 
         
 
@@ -77,6 +91,9 @@ class DiodeRPC {
           } else {
             throw new Error(`Unknown status in response: '${status}'`);
           }
+        }).catch((error) => {
+          logger.error(`Error during port open: ${error}`);
+          return;
         });
       }
     
@@ -94,10 +111,13 @@ class DiodeRPC {
           if (status === 'ok') {
             try {
               const ticketCommand = await this.connection.createTicketCommand();
-              const ticketResponse = await this.connection.sendCommand(ticketCommand);
-              console.log('Ticket updated:', ticketResponse);
+              const ticketResponse = await this.connection.sendCommand(ticketCommand).catch((error) => {
+                logger.error(`Error during ticket command: ${error}`);
+                throw error;
+              });
+              logger.debug(`Ticket updated: ${makeReadable(ticketResponse)}`);
             } catch (error) {
-              console.error('Error updating ticket:', error);
+              logger.error(`Error updating ticket: ${error}`);
               throw error;
             }
             return;
@@ -106,6 +126,9 @@ class DiodeRPC {
           } else {
             throw new Error(`Unknown status in response: '${status}'`);
           }
+        }).catch((error) => {
+          logger.error(`Error during port send: ${error}`);
+          return;
         });
       }
     
@@ -124,24 +147,33 @@ class DiodeRPC {
           } else {
             throw new Error(`Unknown status in response: '${status}'`);
           }
+        }).catch((error) => {
+          logger.error(`Error during port close: ${error}`);
+          return;
         });
       }
 
       sendError(sessionId, ref, error) {
-        return this.connection.sendCommandWithSessionId(['response', ref, 'error', error], sessionId);
+        return this.connection.sendCommandWithSessionId(['response', ref, 'error', error], sessionId).catch((error) => {
+          logger.error(`Error during send error: ${error}`);
+          return;
+        });
       }
 
       sendResponse(sessionId, ref, response) {
-        return this.connection.sendCommandWithSessionId(['response', ref, response], sessionId);
+        return this.connection.sendCommandWithSessionId(['response', ref, response], sessionId).catch((error) => {
+          logger.error(`Error during send response: ${error}`);
+          return;
+        });
       }
 
       async getEpoch() {
         const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
         if (this.epochCache.expiry && this.epochCache.expiry > currentTime) {
-          console.log('Using cached epoch:', this.epochCache.epoch);
+          logger.debug(`Using cached epoch: ${this.epochCache.epoch}`);
           return this.epochCache.epoch;
         }
-        console.log('Fetching new epoch. Expiry:', this.epochCache.expiry);
+        logger.debug(`Fetching new epoch. Expiry: ${this.epochCache.expiry}, Current time: ${currentTime}`);
         const blockPeak = await this.getBlockPeak();
         const blockHeader = await this.getBlockHeader(blockPeak);
     
@@ -175,4 +207,3 @@ class DiodeRPC {
   }
   
   module.exports = DiodeRPC;
-  

package/utils.js

@@ -1,5 +1,11 @@
 // utils.js
 const { Buffer } = require('buffer');
+const logger = require('./logger');
+const { KJUR } = require("jsrsasign");
+const { KEYUTIL } = require("jsrsasign");
+const fs = require('fs');
+var path = require('path');
+
 function makeReadable(decodedMessage) {
   if (Array.isArray(decodedMessage)) {
     return decodedMessage.map((item) => makeReadable(item));
@@ -46,10 +52,10 @@ function parseRequestId(requestIdRaw) {
 }
 
 function parseResponseType(responseTypeRaw) {
-  console.log('responseTypeRaw:', responseTypeRaw);
-  console.log('Type of responseTypeRaw:', typeof responseTypeRaw);
-  console.log('Instance of responseTypeRaw:', responseTypeRaw instanceof Uint8Array);
-  console.log('Is Array:', Array.isArray(responseTypeRaw));
+  logger.debug(`responseTypeRaw: ${responseTypeRaw}`);
+  logger.debug(`Type of responseTypeRaw: ${typeof responseTypeRaw}`);
+  logger.debug(`Instance of responseTypeRaw: ${responseTypeRaw instanceof Uint8Array}`);
+  logger.debug(`Is Array: ${Array.isArray(responseTypeRaw)}`);
   if (responseTypeRaw instanceof Uint8Array || Buffer.isBuffer(responseTypeRaw)) {
     return Buffer.from(responseTypeRaw).toString('utf8');
   } else if (Array.isArray(responseTypeRaw)) {
@@ -74,4 +80,45 @@ function parseReason(reasonRaw) {
   }
 }
 
-module.exports = { makeReadable, parseRequestId, parseResponseType, parseReason };
+function generateCert(path) {
+  var kp = KEYUTIL.generateKeypair("EC", "secp256k1");
+
+  var priv = KEYUTIL.getPEM(kp.prvKeyObj, "PKCS8PRV");
+
+  pub = KEYUTIL.getPEM(kp.pubKeyObj, "PKCS8PUB");
+
+  var x = new KJUR.asn1.x509.Certificate({
+      version: 3,
+      serial: { int: 4 },
+      issuer: { str: "/CN=device" },
+      subject: { str: "/CN=device" },
+      sbjpubkey: kp.pubKeyObj, 
+      ext: [
+          { extname: "basicConstraints", cA: false },
+          { extname: "keyUsage", critical: true, names: ["digitalSignature"] },
+          {
+              extname: "cRLDistributionPoints",
+              array: [{ fulluri: 'https://diode.io/' }]
+          }
+      ],
+      sigalg: "SHA256withECDSA",
+      cakey: kp.prvKeyObj
+  });
+
+
+  const pemFile = priv + x.getPEM();
+  ensureDirectoryExistence(path);
+
+  fs.writeFileSync(path, pemFile , 'utf8');
+}
+
+function ensureDirectoryExistence(filePath) {
+  var dirname = path.dirname(filePath);
+  if (fs.existsSync(dirname)) {
+    return true;
+  }
+  ensureDirectoryExistence(dirname);
+  fs.mkdirSync(dirname);
+}
+
+module.exports = { makeReadable, parseRequestId, parseResponseType, parseReason, generateCert };