diodejs 0.0.3 → 0.0.4

package/connection.js

@@ -47,7 +47,7 @@ class DiodeConnection extends EventEmitter {
         // Send the ticketv2 command
         try {
           const ticketCommand = await this.createTicketCommand();
-          const response = await this.sendCommand(ticketCommand);
+          const response = await this.sendCommand(ticketCommand).catch(reject);
           console.log('Ticket accepted:', response);
           resolve();
         } catch (error) {
@@ -137,10 +137,10 @@ 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "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": {

package/publishPort.js

@@ -8,7 +8,7 @@ const { Buffer } = require('buffer');
 const EventEmitter = require('events');
 const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
-
+const { makeReadable } = require('./utils');
 class DiodeSocket extends Duplex {
   constructor(ref, rpc) {
     super();
@@ -70,15 +70,26 @@ 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}`);
 
     // 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)) {
@@ -233,7 +244,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) {

package/rpc.js

@@ -25,35 +25,47 @@ class DiodeRPC {
             throw new Error('Invalid block number format. response:', makeReadable(responseData));
           }
           return blockNumber;
+        }).catch((error) => {
+          console.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) => {
+        console.error('Error during get block header:', error);
+        return;
       });
     }
   
     getBlock(index) {
       return this.connection.sendCommand(['getblock', index]).then((responseData) => {
         return responseData[0]; // block
+      }).catch((error) => {
+        console.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) => {
+          console.error('Error during ping:', error);
+          return false;
+        })
+    }
 
         
 
@@ -77,6 +89,9 @@ class DiodeRPC {
           } else {
             throw new Error(`Unknown status in response: '${status}'`);
           }
+        }).catch((error) => {
+          console.error('Error during port open:', error);
+          return;
         });
       }
     
@@ -94,7 +109,10 @@ class DiodeRPC {
           if (status === 'ok') {
             try {
               const ticketCommand = await this.connection.createTicketCommand();
-              const ticketResponse = await this.connection.sendCommand(ticketCommand);
+              const ticketResponse = await this.connection.sendCommand(ticketCommand).catch((error) => {
+                console.error('Error during ticket command:', error);
+                throw error;
+              });
               console.log('Ticket updated:', ticketResponse);
             } catch (error) {
               console.error('Error updating ticket:', error);
@@ -106,6 +124,9 @@ class DiodeRPC {
           } else {
             throw new Error(`Unknown status in response: '${status}'`);
           }
+        }).catch((error) => {
+          console.error('Error during port send:', error);
+          return;
         });
       }
     
@@ -124,15 +145,24 @@ class DiodeRPC {
           } else {
             throw new Error(`Unknown status in response: '${status}'`);
           }
+        }).catch((error) => {
+          console.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) => {
+          console.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) => {
+          console.error('Error during send response:', error);
+          return;
+        });
       }
 
       async getEpoch() {