diodejs 0.2.1 → 0.2.2

package/connection.js

@@ -114,7 +114,7 @@ class DiodeConnection extends EventEmitter {
       });
 
       this.socket.on('data', (data) => {
-        logger.debug(`Received data: ${data.toString('hex')}`);
+        // logger.debug(`Received data: ${data.toString('hex')}`);
         try {
           this._handleData(data);
         } catch (error) {
@@ -274,7 +274,7 @@ class DiodeConnection extends EventEmitter {
   _handleData(data) {
     // Append new data to the receive buffer
     this.receiveBuffer = Buffer.concat([this.receiveBuffer, data]);
-    logger.debug(`Received data: ${data.toString('hex')}`);
+    // logger.debug(`Received data: ${data.toString('hex')}`);
   
     let offset = 0;
     while (offset + 2 <= this.receiveBuffer.length) {
@@ -292,7 +292,7 @@ class DiodeConnection extends EventEmitter {
   
       try {
         const decodedMessage = RLP.decode(Uint8Array.from(messageBuffer));
-        logger.debug(`Decoded message: ${makeReadable(decodedMessage)}`);
+        // logger.debug(`Decoded message: ${makeReadable(decodedMessage)}`);
     
         if (Array.isArray(decodedMessage) && decodedMessage.length > 1) {
           const requestIdRaw = decodedMessage[0];
@@ -349,7 +349,7 @@ class DiodeConnection extends EventEmitter {
             this.pendingRequests.delete(requestId);
           } else {
             // This is an unsolicited message
-            logger.debug(`Received unsolicited message: ${makeReadable(decodedMessage)}`);
+            logger.debug(`Received unsolicited message`);
             this.emit('unsolicited', decodedMessage);
           }
         } else {
@@ -406,7 +406,7 @@ class DiodeConnection extends EventEmitter {
         const message = Buffer.concat([lengthBuffer, commandBuffer]);
   
         logger.debug(`Sending command with requestId ${requestId}: ${commandArray}`);
-        logger.debug(`Command buffer: ${message.toString('hex')}`);
+        // logger.debug(`Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
       }).catch(reject);
@@ -433,7 +433,7 @@ class DiodeConnection extends EventEmitter {
         const message = Buffer.concat([lengthBuffer, commandBuffer]);
   
         logger.debug(`Sending command with requestId ${requestId}: ${commandArray}`);
-        logger.debug(`Command buffer: ${message.toString('hex')}`);
+        // logger.debug(`Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
       }).catch(reject);
@@ -644,21 +644,22 @@ class DiodeConnection extends EventEmitter {
     const timeSinceLastUpdate = Date.now() - this.lastTicketUpdate;
     
     if (force || 
-        this.accumulatedBytes >= this.ticketUpdateThreshold || 
-        timeSinceLastUpdate >= this.ticketUpdateInterval) {
+      (this.accumulatedBytes > 0 && 
+      (this.accumulatedBytes >= this.ticketUpdateThreshold || 
+      timeSinceLastUpdate >= this.ticketUpdateInterval))) {
       
       try {
-        if (this.accumulatedBytes > 0 || force) {
-          logger.debug(`Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
-          const ticketCommand = await this.createTicketCommand();
-          await this.sendCommand(ticketCommand);
-          
-          // Reset counters
-          this.accumulatedBytes = 0;
-          this.lastTicketUpdate = Date.now();
-        }
+      if (this.accumulatedBytes > 0 || force) {
+        logger.debug(`Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
+        const ticketCommand = await this.createTicketCommand();
+        await this.sendCommand(ticketCommand);
+        
+        // Reset counters
+        this.accumulatedBytes = 0;
+        this.lastTicketUpdate = Date.now();
+      }
       } catch (error) {
-        logger.error(`Error updating ticket: ${error}`);
+      logger.error(`Error updating ticket: ${error}`);
       }
     }
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "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/rpc.js

@@ -102,24 +102,51 @@ class DiodeRPC {
         const bytesToSend = data.length;
         this.connection.addBytes(bytesToSend);
     
-        // Now send the data
-        return this.connection.sendCommand(['portsend', ref, data]).then(async (responseData) => {
-          // responseData is [status]
-          const [statusRaw] = responseData;
-          const status = parseResponseType(statusRaw);
-      
-          if (status === 'ok') {
-            // No ticket update here anymore - handled by batching mechanism
-            return;
-          } else if (status === 'error') {
-            throw new Error('Error during port send');
+        // Maximum size that can be sent in a single message (less than 65535 to be safe)
+        const MAX_CHUNK_SIZE = 65000;
+        
+        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`);
+            let offset = 0;
+            
+            while (offset < data.length) {
+              const chunkSize = Math.min(MAX_CHUNK_SIZE, data.length - offset);
+              const chunk = data.slice(offset, offset + chunkSize);
+              
+              // Send this chunk
+              const responseData = await this.connection.sendCommand(['portsend', ref, chunk]);
+              const [statusRaw] = responseData;
+              const status = parseResponseType(statusRaw);
+              
+              if (status !== 'ok') {
+                throw new Error(`Error during chunked port send: ${status}`);
+              }
+              
+              offset += chunkSize;
+            }
+            
+            return; // All chunks sent successfully
           } else {
-            throw new Error(`Unknown status in response: '${status}'`);
+            // Small enough to send in one piece
+            return this.connection.sendCommand(['portsend', ref, data]).then((responseData) => {
+              const [statusRaw] = responseData;
+              const status = parseResponseType(statusRaw);
+          
+              if (status === 'ok') {
+                return;
+              } else if (status === 'error') {
+                throw new Error('Error during port send');
+              } else {
+                throw new Error(`Unknown status in response: '${status}'`);
+              }
+            });
           }
-        }).catch((error) => {
+        } catch (error) {
           logger.error(`Error during port send: ${error}`);
-          return;
-        });
+          throw error; // Rethrow to allow proper error handling upstream
+        }
       }
     
       portClose(ref) {

package/utils.js

@@ -52,10 +52,6 @@ function parseRequestId(requestIdRaw) {
 }
 
 function parseResponseType(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)) {