diodejs 0.2.0 → 0.2.1

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}`);
@@ -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);
@@ -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,79 @@ 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 >= 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.1",
   "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,9 +98,9 @@ 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) => {
@@ -109,17 +109,7 @@ class DiodeRPC {
           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;
-            }
+            // No ticket update here anymore - handled by batching mechanism
             return;
           } else if (status === 'error') {
             throw new Error('Error during port send');
@@ -192,17 +182,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);
       }
   }