diodejs 0.1.6 → 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)
@@ -117,15 +125,23 @@ async function main() {
   
     // Multiple or single port binding with configuration object
     const portsConfig = {
-      3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" },
-      3003: { targetPort: 443, deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2" } // Works with or without 0x prefix
+      3002: { 
+        targetPort: 80, 
+        deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2",
+        protocol: "tls" // Optional - defaults to TLS if not specified
+      },
+      3003: { 
+        targetPort: 443, 
+        deviceIdHex: "0x5365baf29cb7ab58de588dfc448913cb609283e2",
+        protocol: "tcp" // Can be "tls", "tcp", or "udp"
+      }
     };
     
     const portForward = new BindPort(connection, portsConfig);
     portForward.bind();
     
-    // You can also dynamically add and remove ports
-    portForward.addPort(3004, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    // You can also dynamically add ports with protocol specification
+    portForward.addPort(3004, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2", "udp");
     portForward.removePort(3003);
 }
 
@@ -144,7 +160,7 @@ async function main() {
     const connection = new DiodeConnection(host, port, keyLocation);
     await connection.connect();
   
-    // Legacy method - single port binding
+    // Legacy method - single port binding (defaults to TLS protocol)
     const portForward = new BindPort(connection, 3002, 80, "5365baf29cb7ab58de588dfc448913cb609283e2");
     portForward.bind();
 }
@@ -211,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
@@ -249,13 +267,15 @@ main();
   New Constructor:
   - `new BindPort(connection, portsConfig)`
     - `connection` (DiodeConnection): An instance of `DiodeConnection`.
-    - `portsConfig` (object): A configuration object where keys are local ports and values are objects with `targetPort` and `deviceIdHex`.
-      Example: `{ 3002: { targetPort: 80, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" } }`
-      Note: deviceIdHex can be provided with or without the '0x' prefix.
+    - `portsConfig` (object): A configuration object where keys are local ports and values are objects with:
+      - `targetPort` (number): The target port on the device.
+      - `deviceIdHex` (string): The device ID in hexadecimal format (with or without '0x' prefix).
+      - `protocol` (string, optional): The protocol to use ("tls", "tcp", or "udp"). Defaults to "tls".
 
 - **Methods**:
   - `bind()`: Binds all configured local ports to their target ports on the devices.
-  - `addPort(localPort, targetPort, deviceIdHex)`: Adds a new port binding configuration. deviceIdHex can include '0x' prefix.
+  - `addPort(localPort, targetPort, deviceIdHex, protocol)`: Adds a new port binding configuration.
+    - `protocol` (string, optional): The protocol to use. Can be "tls", "tcp", or "udp". Defaults to "tls".
   - `removePort(localPort)`: Removes a port binding configuration.
   - `bindSinglePort(localPort)`: Binds a single local port to its target.
   - `closeAllServers()`: Closes all active server instances.

package/bindPort.js

@@ -1,8 +1,45 @@
 const net = require('net');
+const tls = require('tls');
+const dgram = require('dgram');
 const { Buffer } = require('buffer');
+const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
 const logger = require('./logger');
 
+// Custom Duplex stream to handle the Diode connection
+class DiodeSocket extends Duplex {
+  constructor(ref, rpc) {
+    super();
+    this.ref = ref;
+    this.rpc = rpc;
+    this.destroyed = false;
+  }
+
+  _write(chunk, encoding, callback) {
+    // Send data to the remote device via portSend
+    this.rpc.portSend(this.ref, chunk)
+      .then(() => callback())
+      .catch((err) => callback(err));
+  }
+
+  _read(size) {
+    // No need to implement this method for our use case
+  }
+
+  // Method to push data received from the remote device
+  pushData(data) {
+    if (!this.destroyed) {
+      this.push(data);
+    }
+  }
+
+  _destroy(err, callback) {
+    this.destroyed = true;
+    this.push(null);
+    callback(err);
+  }
+}
+
 class BindPort {
   constructor(connection, localPortOrPortsConfig, targetPort, deviceIdHex) {
     this.connection = connection;
@@ -12,7 +49,8 @@ class BindPort {
       this.portsConfig = {
         [localPortOrPortsConfig]: { 
           targetPort, 
-          deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+          deviceIdHex: this._stripHexPrefix(deviceIdHex),
+          protocol: 'tls' // Default protocol is tls
         }
       };
     } else {
@@ -20,10 +58,17 @@ class BindPort {
       this.portsConfig = localPortOrPortsConfig || {};
       
       // Strip 0x prefix from all deviceIdHex values in portsConfig
+      // And ensure protocol is specified (default to tls)
       for (const port in this.portsConfig) {
         if (this.portsConfig[port].deviceIdHex) {
           this.portsConfig[port].deviceIdHex = this._stripHexPrefix(this.portsConfig[port].deviceIdHex);
         }
+        // Set default protocol if not provided
+        if (!this.portsConfig[port].protocol) {
+          this.portsConfig[port].protocol = 'tls';
+        }
+        // Ensure protocol is uppercase
+        this.portsConfig[port].protocol = this.portsConfig[port].protocol.toLowerCase();
       }
     }
     
@@ -45,7 +90,6 @@ class BindPort {
   _setupMessageListener() {
     // Listen for data events from the device
     this.connection.on('unsolicited', (message) => {
-      // message is [messageId, [messageType, ...]]
       const [messageIdRaw, messageContent] = message;
       const messageTypeRaw = messageContent[0];
       const messageType = Buffer.from(messageTypeRaw).toString('utf8');
@@ -60,7 +104,13 @@ class BindPort {
         // Find the associated client socket from connection
         const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
-          clientSocket.write(data);
+          if (clientSocket.diodeSocket) {
+            // If it's a DiodeSocket, push data to it so tls can process
+            clientSocket.diodeSocket.pushData(data);
+          } else {
+            // Otherwise write directly to the socket
+            clientSocket.write(data);
+          }
         } else {
           const connectionInfo = this.connection.getConnection(dataRef);
           if (connectionInfo) {
@@ -76,6 +126,9 @@ class BindPort {
         // Close the associated client socket
         const clientSocket = this.connection.getClientSocket(dataRef);
         if (clientSocket) {
+          if (clientSocket.diodeSocket) {
+            clientSocket.diodeSocket._destroy(null, () => {});
+          }
           clientSocket.end();
           this.connection.deleteClientSocket(dataRef);
           logger.info(`Port closed for ref: ${dataRef.toString('hex')}`);
@@ -100,7 +153,7 @@ class BindPort {
     });
   }
 
-  addPort(localPort, targetPort, deviceIdHex) {
+  addPort(localPort, targetPort, deviceIdHex, protocol = 'tls') {
     if (this.servers.has(localPort)) {
       logger.warn(`Port ${localPort} is already bound`);
       return false;
@@ -108,7 +161,8 @@ class BindPort {
     
     this.portsConfig[localPort] = { 
       targetPort, 
-      deviceIdHex: this._stripHexPrefix(deviceIdHex) 
+      deviceIdHex: this._stripHexPrefix(deviceIdHex),
+      protocol: protocol.toLowerCase()
     };
     
     this.bindSinglePort(localPort);
@@ -151,70 +205,191 @@ class BindPort {
       return false;
     }
     
-    const { targetPort, deviceIdHex } = config;
+    const { targetPort, deviceIdHex, protocol = 'tls' } = config;
     const deviceId = Buffer.from(deviceIdHex, 'hex');
     
-    // Set up local server
-    const server = net.createServer(async (clientSocket) => {
-      logger.info(`Client connected to local server on port ${localPort}`);
-
-      // Open a new port on the device for this client
-      let ref;
-      try {
-        ref = await this.rpc.portOpen(deviceId, targetPort, 'rw');
+    // Format the target port with protocol prefix for the remote connection
+    const formattedTargetPort = `${protocol}:${targetPort}`;
+    logger.info(`Binding local port ${localPort} to remote ${formattedTargetPort}`);
+    
+    // For udp protocol, use udp server
+    if (protocol === 'udp') {
+      const server = dgram.createSocket('udp4');
+      
+      server.on('listening', () => {
+        logger.info(`udp server listening on port ${localPort} forwarding to device port ${targetPort}`);
+      });
+      
+      server.on('message', async (data, rinfo) => {
+        // Open a new port on the device if this is a new client
+        const clientKey = `${rinfo.address}:${rinfo.port}`;
+        let ref = server.clientRefs && server.clientRefs[clientKey];
+        
         if (!ref) {
-          logger.error(`Error opening port ${targetPort} on deviceId: ${deviceIdHex}`);
-          clientSocket.destroy();
-          return;
-        } else {
-          logger.info(`Port ${targetPort} opened on device with ref: ${ref.toString('hex')} for client`);
+          try {
+            ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
+            if (!ref) {
+              logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+              return;
+            } else {
+              logger.info(`Port ${formattedTargetPort} opened on device with ref: ${ref.toString('hex')} for udp client ${clientKey}`);
+              if (!server.clientRefs) server.clientRefs = {};
+              server.clientRefs[clientKey] = ref;
+              
+              // Store the client info
+              this.connection.addClientSocket(ref, {
+                address: rinfo.address,
+                port: rinfo.port,
+                protocol: 'udp',
+                write: (data) => {
+                  server.send(data, rinfo.port, rinfo.address);
+                }
+              });
+            }
+          } catch (error) {
+            logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+            return;
+          }
         }
-      } catch (error) {
-        logger.error(`Error opening port ${targetPort} on device: ${error}`);
-        clientSocket.destroy();
-        return;
-      }
-
-      // Store the client socket with the ref using connection's method
-      this.connection.addClientSocket(ref, clientSocket);
-
-      // When data is received from the client, send it to the device
-      clientSocket.on('data', async (data) => {
+        
+        // Send data to the device
         try {
           await this.rpc.portSend(ref, data);
         } catch (error) {
-          logger.error(`Error sending data to device: ${error}`);
-          clientSocket.destroy();
+          logger.error(`Error sending udp data to device: ${error}`);
         }
       });
+      
+      server.on('error', (err) => {
+        logger.error(`udp Server error: ${err}`);
+      });
+      
+      server.bind(localPort);
+      this.servers.set(parseInt(localPort), server);
+    } else {
+      // For TCP and tls protocols, use TCP server locally
+      const server = net.createServer(async (clientSocket) => {
+        logger.info(`Client connected to local server on port ${localPort}`);
 
-      // Handle client socket closure
-      clientSocket.on('end', async () => {
-        logger.info('Client disconnected');
-        if (ref && this.connection.hasClientSocket(ref)) {
+        // Open a new port on the device for this client
+        let ref;
+        try {
+          ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
+          if (!ref) {
+            logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+            clientSocket.destroy();
+            return;
+          } else {
+            logger.info(`Port ${formattedTargetPort} opened on device with ref: ${ref.toString('hex')} for client`);
+          }
+        } catch (error) {
+          logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+          clientSocket.destroy();
+          return;
+        }
+
+        if (protocol === 'tls') {
+          // For tls protocol, create a proper tls connection
           try {
-            await this.rpc.portClose(ref);
-            logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
-            this.connection.deleteClientSocket(ref);
+            // Create a DiodeSocket to handle communication with the device
+            const diodeSocket = new DiodeSocket(ref, this.rpc);
+            
+            // Get the device certificate for tls
+            const certPem = this.connection.getDeviceCertificate();
+            if (!certPem) {
+              throw new Error('No device certificate available');
+            }
+            
+            // Setup tls options for client mode
+            const tlsOptions = {
+              cert: certPem,
+              key: certPem,
+              rejectUnauthorized: false,
+              ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+              ecdhCurve: 'secp256k1',
+              minVersion: 'TLSv1.2',
+              maxVersion: 'TLSv1.2',
+            };
+            
+            // Create tls socket as client (not server)
+            const tlsSocket = tls.connect({
+              socket: diodeSocket,
+              ...tlsOptions
+            }, () => {
+              logger.info(`tls connection established to device ${deviceIdHex}`);
+            });
+            
+            // Pipe data between the client socket and the tls socket
+            tlsSocket.pipe(clientSocket).pipe(tlsSocket);
+            
+            // Handle tls socket errors
+            tlsSocket.on('error', (err) => {
+              logger.error(`tls Socket error: ${err}`);
+              clientSocket.destroy();
+            });
+            
+            // Store reference to the diodeSocket so we can push data to it
+            const socketWrapper = {
+              diodeSocket,
+              tlsSocket,
+              end: () => {
+                tlsSocket.end();
+                diodeSocket._destroy(null, () => {});
+              }
+            };
+            
+            // Store the socket wrapper
+            this.connection.addClientSocket(ref, socketWrapper);
+            
           } catch (error) {
-            logger.error(`Error closing port on device: ${error}`);
+            logger.error(`Error setting up tls connection: ${error}`);
+            clientSocket.destroy();
+            return;
           }
         } else {
-          logger.warn('Ref is invalid or no longer in clientSockets.');
+          // For TCP protocol, just use the raw socket
+          this.connection.addClientSocket(ref, clientSocket);
+          
+          // Handle data from client to device
+          clientSocket.on('data', async (data) => {
+            try {
+              await this.rpc.portSend(ref, data);
+            } catch (error) {
+              logger.error(`Error sending data to device: ${error}`);
+              clientSocket.destroy();
+            }
+          });
         }
-      });
 
-      // Handle client socket errors
-      clientSocket.on('error', (err) => {
-        logger.error('Client socket error:', err);
+        // Handle client socket closure (common for all protocols)
+        clientSocket.on('end', async () => {
+          logger.info('Client disconnected');
+          if (ref && this.connection.hasClientSocket(ref)) {
+            try {
+              await this.rpc.portClose(ref);
+              logger.info(`Port closed on device for ref: ${ref.toString('hex')}`);
+              this.connection.deleteClientSocket(ref);
+            } 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) => {
+          logger.error(`Client socket error: ${err}`);
+        });
       });
-    });
 
-    server.listen(localPort, () => {
-      logger.info(`Local server listening on port ${localPort} forwarding to device port ${targetPort}`);
-    });
+      server.listen(localPort, () => {
+        logger.info(`Local server listening on port ${localPort} forwarding to device ${protocol} port ${targetPort}`);
+      });
+      
+      this.servers.set(parseInt(localPort), server);
+    }
     
-    this.servers.set(parseInt(localPort), server);
     return true;
   }
 

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/examples/portForwardTest.js

@@ -9,8 +9,8 @@ async function main() {
     await connection.connect();
   
     const portForward = new BindPort(connection, {
-        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039" },
-        3004: { targetPort: 443, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2" }
+        3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", protocol: "tcp" },
+        3004: { targetPort: 8081, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2", protocol: "tls" }
       });
     portForward.bind();
 
@@ -23,7 +23,7 @@ async function main() {
     // after 10 seconds, add port 3003 back
     setTimeout(() => {
         console.log("Adding port 3003 back");
-        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039");
+        portForward.addPort(3003, 8080, "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", "tcp");
     }, 10000);
     
     

package/package.json

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

@@ -254,7 +254,7 @@ class PublishPort extends EventEmitter {
     // Create a DiodeSocket instance
     const diodeSocket = new DiodeSocket(ref, this.rpc);
 
-    certPem = this.connection.getDeviceCertificate();
+    const certPem = this.connection.getDeviceCertificate();
 
     // TLS options with your server's certificate and key
     const tlsOptions = {

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);
       }
   }