diodejs 0.2.0 → 0.2.2

package/README.md

@@ -25,6 +25,8 @@ Connection retry behavior can be configured via environment variables:
 | DIODE_RETRY_DELAY | Initial delay between retries (ms) | 1000 |
 | DIODE_MAX_RETRY_DELAY | Maximum delay between retries (ms) | 30000 |
 | DIODE_AUTO_RECONNECT | Whether to automatically reconnect | true |
+| DIODE_TICKET_BYTES_THRESHOLD | Bytes threshold for ticket updates | 512000 (512KB) |
+| DIODE_TICKET_UPDATE_INTERVAL | Time interval for ticket updates (ms) | 30000 (30s) |
 
 Example `.env` file:
 ```
@@ -32,6 +34,8 @@ DIODE_MAX_RETRIES=10
 DIODE_RETRY_DELAY=2000
 DIODE_MAX_RETRY_DELAY=20000
 DIODE_AUTO_RECONNECT=true
+DIODE_TICKET_BYTES_THRESHOLD=512000
+DIODE_TICKET_UPDATE_INTERVAL=30000
 ```
 
 These settings can also be configured programmatically:
@@ -40,7 +44,9 @@ connection.setReconnectOptions({
   maxRetries: 10,
   retryDelay: 2000,
   maxRetryDelay: 20000,
-  autoReconnect: true
+  autoReconnect: true,
+  ticketBytesThreshold: 512000,
+  ticketUpdateInterval: 30000
 });
 ```
 
@@ -63,7 +69,9 @@ async function main() {
     maxRetries: Infinity, // Unlimited reconnection attempts
     retryDelay: 1000,     // Initial delay of 1 second
     maxRetryDelay: 30000, // Maximum delay of 30 seconds
-    autoReconnect: true   // Automatically reconnect on disconnection
+    autoReconnect: true,  // Automatically reconnect on disconnection
+    ticketBytesThreshold: 512000, // Bytes threshold for ticket updates
+    ticketUpdateInterval: 30000   // Time interval for ticket updates
   });
   
   // Listen for reconnection events (optional)
@@ -219,6 +227,8 @@ main();
     - `retryDelay` (number): Initial delay between retries in ms (default: 1000)
     - `maxRetryDelay` (number): Maximum delay between retries in ms (default: 30000)
     - `autoReconnect` (boolean): Whether to automatically reconnect on disconnection (default: true)
+    - `ticketBytesThreshold` (number): Bytes threshold for ticket updates (default: 512000)
+    - `ticketUpdateInterval` (number): Time interval for ticket updates in ms (default: 30000)
 
 - **Events**:
   - `reconnecting`: Emitted when a reconnection attempt is about to start, with `attempt` and `delay` information

package/connection.js

@@ -62,6 +62,16 @@ class DiodeConnection extends EventEmitter {
     logger.info(`Connection settings - Auto Reconnect: ${this.autoReconnect}, Max Retries: ${
       this.maxRetries === Infinity ? 'Infinity' : this.maxRetries
     }, Retry Delay: ${this.retryDelay}ms, Max Retry Delay: ${this.maxRetryDelay}ms`);
+
+    // Add ticket batching configuration
+    this.lastTicketUpdate = Date.now();
+    this.accumulatedBytes = 0;
+    this.ticketUpdateThreshold = parseInt(process.env.DIODE_TICKET_BYTES_THRESHOLD, 10) || 512000; // 512KB default
+    this.ticketUpdateInterval = parseInt(process.env.DIODE_TICKET_UPDATE_INTERVAL, 10) || 30000; // 30 seconds default
+    this.ticketUpdateTimer = null;
+    
+    // Log the ticket batching settings
+    logger.info(`Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
   }
 
   connect() {
@@ -96,7 +106,6 @@ class DiodeConnection extends EventEmitter {
         try {
           const ticketCommand = await this.createTicketCommand();
           const response = await this.sendCommand(ticketCommand).catch(reject);
-          logger.info(`Ticket accepted: ${makeReadable(response)}`);
           resolve();
         } catch (error) {
           logger.error(`Error sending ticket: ${error}`);
@@ -105,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) {
@@ -113,6 +122,11 @@ class DiodeConnection extends EventEmitter {
         }
       });
 
+      // Start the periodic ticket update timer after successful connection
+      this.socket.on('connect', () => {
+        this._startTicketUpdateTimer();
+      });
+
       this.socket.on('error', (err) => {
         logger.error(`Connection error: ${err}`);
           reject(err);
@@ -242,6 +256,11 @@ class DiodeConnection extends EventEmitter {
 
   // Update close method to prevent reconnection when intentionally closing
   close() {
+    if (this.ticketUpdateTimer) {
+      clearTimeout(this.ticketUpdateTimer);
+      this.ticketUpdateTimer = null;
+    }
+    
     this.autoReconnect = false;
     if (this.retryTimeoutId) {
       clearTimeout(this.retryTimeoutId);
@@ -255,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) {
@@ -273,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];
@@ -330,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 {
@@ -387,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);
@@ -414,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);
@@ -431,7 +450,6 @@ class DiodeConnection extends EventEmitter {
       const addressBuffer = ethUtil.pubToAddress(publicKeyBuffer, true);
       const address = '0x' + addressBuffer.toString('hex');
 
-      logger.info(`Ethereum address: ${address}`);
       return address;
     } catch (error) {
       logger.error(`Error extracting Ethereum address: ${error}`);
@@ -455,7 +473,6 @@ class DiodeConnection extends EventEmitter {
       const addressBuffer = ethUtil.pubToAddress(publicKeyBuffer, true);
       const address = '0x' + addressBuffer.toString('hex');
 
-      logger.info(`Server Ethereum address: ${address}`);
       return address;
     } catch (error) {
       logger.error(`Error extracting server Ethereum address: ${error}`);
@@ -605,6 +622,80 @@ class DiodeConnection extends EventEmitter {
   hasConnection(ref) {
     return this.connections.has(ref.toString('hex'));
   }
+
+  // Start timer for periodic ticket updates
+  _startTicketUpdateTimer() {
+    if (this.ticketUpdateTimer) {
+      clearTimeout(this.ticketUpdateTimer);
+    }
+    
+    this.ticketUpdateTimer = setTimeout(() => {
+      this._updateTicketIfNeeded(true);
+    }, this.ticketUpdateInterval);
+  }
+
+  // Method to check if ticket update is needed and perform it
+  async _updateTicketIfNeeded(force = false) {
+    // If socket is not connected, don't try to update
+    if (!this.socket || this.socket.destroyed) {
+      return;
+    }
+    
+    const timeSinceLastUpdate = Date.now() - this.lastTicketUpdate;
+    
+    if (force || 
+      (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();
+      }
+      } catch (error) {
+      logger.error(`Error updating ticket: ${error}`);
+      }
+    }
+    
+    // Restart the timer
+    this._startTicketUpdateTimer();
+  }
+
+  // Add method to track bytes without immediate ticket update
+  addBytes(bytesCount) {
+    this.totalBytes += bytesCount;
+    this.accumulatedBytes += bytesCount;
+    
+    // Optionally check if we should update ticket now
+    if (this.accumulatedBytes >= this.ticketUpdateThreshold) {
+      this._updateTicketIfNeeded();
+    }
+  }
+
+  // Method to set ticket batching options
+  setTicketBatchingOptions(options = {}) {
+    if (typeof options.threshold === 'number') {
+      this.ticketUpdateThreshold = options.threshold;
+    }
+    if (typeof options.interval === 'number') {
+      this.ticketUpdateInterval = options.interval;
+    }
+    
+    logger.info(`Updated ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
+    
+    // Reset the timer with new interval
+    if (this.socket && !this.socket.destroyed) {
+      this._startTicketUpdateTimer();
+    }
+    
+    return this;
+  }
 }
 
 

package/package.json

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

@@ -98,38 +98,55 @@ class DiodeRPC {
       }
     
       async portSend(ref, data) {
-        // Update totalBytes
+        // Update bytes count but don't update ticket yet
         const bytesToSend = data.length;
-        this.connection.totalBytes += bytesToSend;
+        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') {
-            try {
-              const ticketCommand = await this.connection.createTicketCommand();
-              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) {
-              logger.error(`Error updating ticket: ${error}`);
-              throw error;
+        // 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;
-          } else if (status === 'error') {
-            throw new Error('Error during port send');
+            
+            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) {
@@ -192,17 +209,40 @@ class DiodeRPC {
         return epoch;
       }
     
-      parseTimestamp(blockHeader) {
-        // Implement parsing of timestamp from blockHeader
-        const timestampRaw = blockHeader[0][1]; // Adjust index based on actual structure
-        //Timestamp Raw: [ 'timestamp', 1726689425 ]
-        if (timestampRaw instanceof Uint8Array || Buffer.isBuffer(timestampRaw)) {
-          return Buffer.from(timestampRaw).readUIntBE(0, timestampRaw.length);
-        } else if (typeof timestampRaw === 'number') {
-          return timestampRaw;
-        } else {
-          throw new Error('Invalid timestamp format in block header');
+      parseTimestamp(blockHeader) {        
+        // Search for the timestamp field by name
+        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
+                  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');
+        return Math.floor(Date.now() / 1000);
       }
   }
   

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)) {