diodejs 0.2.2 → 0.3.0

package/bindPort.js

@@ -2,6 +2,7 @@ const net = require('net');
 const tls = require('tls');
 const dgram = require('dgram');
 const { Buffer } = require('buffer');
+const { toBufferView } = require('./utils');
 const { Duplex } = require('stream');
 const DiodeRPC = require('./rpc');
 const logger = require('./logger');
@@ -9,7 +10,7 @@ const logger = require('./logger');
 // Custom Duplex stream to handle the Diode connection
 class DiodeSocket extends Duplex {
   constructor(ref, rpc) {
-    super();
+    super({ readableHighWaterMark: 256 * 1024, writableHighWaterMark: 256 * 1024, allowHalfOpen: false });
     this.ref = ref;
     this.rpc = rpc;
     this.destroyed = false;
@@ -92,14 +93,14 @@ class BindPort {
     this.connection.on('unsolicited', (message) => {
       const [messageIdRaw, messageContent] = message;
       const messageTypeRaw = messageContent[0];
-      const messageType = Buffer.from(messageTypeRaw).toString('utf8');
+      const messageType = toBufferView(messageTypeRaw).toString('utf8');
 
       if (messageType === 'data' || messageType === 'portsend') {
         const refRaw = messageContent[1];
         const dataRaw = messageContent[2];
 
-        const dataRef = Buffer.from(refRaw);
-        const data = Buffer.from(dataRaw);
+        const dataRef = toBufferView(refRaw);
+        const data = toBufferView(dataRaw);
 
         // Find the associated client socket from connection
         const clientSocket = this.connection.getClientSocket(dataRef);
@@ -114,14 +115,14 @@ class BindPort {
         } else {
           const connectionInfo = this.connection.getConnection(dataRef);
           if (connectionInfo) {
-            logger.debug(`No client socket found for ref: ${dataRef.toString('hex')}, but connection exists for ${connectionInfo.host}:${connectionInfo.port}`);
+            logger.debug(() => `No client socket found for ref: ${dataRef.toString('hex')}, but connection exists for ${connectionInfo.host}:${connectionInfo.port}`);
           } else {
-            logger.warn(`No client socket found for ref: ${dataRef.toString('hex')}`);
+            logger.warn(() => `No client socket found for ref: ${dataRef.toString('hex')}`);
           }
         }
       } else if (messageType === 'portclose') {
         const refRaw = messageContent[1];
-        const dataRef = Buffer.from(refRaw);
+        const dataRef = toBufferView(refRaw);
 
         // Close the associated client socket
         const clientSocket = this.connection.getClientSocket(dataRef);
@@ -131,31 +132,31 @@ class BindPort {
           }
           clientSocket.end();
           this.connection.deleteClientSocket(dataRef);
-          logger.info(`Port closed for ref: ${dataRef.toString('hex')}`);
+          logger.info(() => `Port closed for ref: ${dataRef.toString('hex')}`);
         }
       } else {
         if (messageType != 'portopen') {
-          logger.warn(`Unknown unsolicited message type: ${messageType}`);
+          logger.warn(() => `Unknown unsolicited message type: ${messageType}`);
         }
       }
     });
     
     // Handle device disconnect
     this.connection.on('end', () => {
-      logger.info('Disconnected from Diode.io server');
+      logger.info(() => 'Disconnected from Diode.io server');
       this.closeAllServers();
     });
 
     // Handle connection errors
     this.connection.on('error', (err) => {
-      logger.error(`Connection error: ${err}`);
+      logger.error(() => `Connection error: ${err}`);
       this.closeAllServers();
     });
   }
 
   addPort(localPort, targetPort, deviceIdHex, protocol = 'tls') {
     if (this.servers.has(localPort)) {
-      logger.warn(`Port ${localPort} is already bound`);
+      logger.warn(() => `Port ${localPort} is already bound`);
       return false;
     }
     
@@ -172,7 +173,7 @@ class BindPort {
   
   removePort(localPort) {
     if (!this.portsConfig[localPort]) {
-      logger.warn(`Port ${localPort} is not configured`);
+      logger.warn(() => `Port ${localPort} is not configured`);
       return false;
     }
     
@@ -180,7 +181,7 @@ class BindPort {
     if (this.servers.has(localPort)) {
       const server = this.servers.get(localPort);
       server.close(() => {
-        logger.info(`Server on port ${localPort} closed`);
+        logger.info(() => `Server on port ${localPort} closed`);
       });
       this.servers.delete(localPort);
     }
@@ -193,7 +194,7 @@ class BindPort {
   closeAllServers() {
     for (const [localPort, server] of this.servers.entries()) {
       server.close();
-      logger.info(`Server on port ${localPort} closed`);
+      logger.info(() => `Server on port ${localPort} closed`);
     }
     this.servers.clear();
   }
@@ -201,7 +202,7 @@ class BindPort {
   bindSinglePort(localPort) {
     const config = this.portsConfig[localPort];
     if (!config) {
-      logger.error(`No configuration found for port ${localPort}`);
+      logger.error(() => `No configuration found for port ${localPort}`);
       return false;
     }
     
@@ -210,14 +211,14 @@ class BindPort {
     
     // Format the target port with protocol prefix for the remote connection
     const formattedTargetPort = `${protocol}:${targetPort}`;
-    logger.info(`Binding local port ${localPort} to remote ${formattedTargetPort}`);
+    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}`);
+        logger.info(() => `udp server listening on port ${localPort} forwarding to device port ${targetPort}`);
       });
       
       server.on('message', async (data, rinfo) => {
@@ -229,10 +230,10 @@ class BindPort {
           try {
             ref = await this.rpc.portOpen(deviceId, formattedTargetPort, 'rw');
             if (!ref) {
-              logger.error(`Error opening port ${formattedTargetPort} on deviceId: ${deviceIdHex}`);
+              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}`);
+              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;
               
@@ -247,7 +248,7 @@ class BindPort {
               });
             }
           } catch (error) {
-            logger.error(`Error opening port ${formattedTargetPort} on device: ${error}`);
+            logger.error(() => `Error opening port ${formattedTargetPort} on device: ${error}`);
             return;
           }
         }
@@ -256,12 +257,12 @@ class BindPort {
         try {
           await this.rpc.portSend(ref, data);
         } catch (error) {
-          logger.error(`Error sending udp data to device: ${error}`);
+          logger.error(() => `Error sending udp data to device: ${error}`);
         }
       });
       
       server.on('error', (err) => {
-        logger.error(`udp Server error: ${err}`);
+        logger.error(() => `udp Server error: ${err}`);
       });
       
       server.bind(localPort);
@@ -269,21 +270,22 @@ class BindPort {
     } 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}`);
+        logger.info(() => `Client connected to local server on port ${localPort}`);
+        clientSocket.setNoDelay(true);
 
         // 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}`);
+            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`);
+            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}`);
+          logger.error(() => `Error opening port ${formattedTargetPort} on device: ${error}`);
           clientSocket.destroy();
           return;
         }
@@ -316,15 +318,16 @@ class BindPort {
               socket: diodeSocket,
               ...tlsOptions
             }, () => {
-              logger.info(`tls connection established to device ${deviceIdHex}`);
+              logger.info(() => `tls connection established to device ${deviceIdHex}`);
             });
+            tlsSocket.setNoDelay(true);
             
             // 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}`);
+              logger.error(() => `tls Socket error: ${err}`);
               clientSocket.destroy();
             });
             
@@ -342,7 +345,7 @@ class BindPort {
             this.connection.addClientSocket(ref, socketWrapper);
             
           } catch (error) {
-            logger.error(`Error setting up tls connection: ${error}`);
+            logger.error(() => `Error setting up tls connection: ${error}`);
             clientSocket.destroy();
             return;
           }
@@ -355,7 +358,7 @@ class BindPort {
             try {
               await this.rpc.portSend(ref, data);
             } catch (error) {
-              logger.error(`Error sending data to device: ${error}`);
+              logger.error(() => `Error sending data to device: ${error}`);
               clientSocket.destroy();
             }
           });
@@ -363,28 +366,28 @@ class BindPort {
 
         // Handle client socket closure (common for all protocols)
         clientSocket.on('end', async () => {
-          logger.info('Client disconnected');
+          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')}`);
+              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}`);
+              logger.error(() => `Error closing port on device: ${error}`);
             }
           } else {
-            logger.warn('Ref is invalid or no longer in clientSockets.');
+            logger.warn(() => 'Ref is invalid or no longer in clientSockets.');
           }
         });
 
         // Handle client socket errors
         clientSocket.on('error', (err) => {
-          logger.error(`Client socket error: ${err}`);
+          logger.error(() => `Client socket error: ${err}`);
         });
       });
 
       server.listen(localPort, () => {
-        logger.info(`Local server listening on port ${localPort} forwarding to device ${protocol} port ${targetPort}`);
+        logger.info(() => `Local server listening on port ${localPort} forwarding to device ${protocol} port ${targetPort}`);
       });
       
       this.servers.set(parseInt(localPort), server);
@@ -404,4 +407,4 @@ class BindPort {
   }
 }
 
-module.exports = BindPort;
+module.exports = BindPort;

package/connection.js

@@ -16,6 +16,15 @@ const path = require('path');
 // Add dotenv for environment variables
 require('dotenv').config();
 
+// Try to use native keccak if available (optional perf boost)
+let nativeKeccak = null;
+try {
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  nativeKeccak = require('keccak');
+} catch (_) {
+  // optional dependency; fallback to ethereumjs-util.keccak256
+}
+
 class DiodeConnection extends EventEmitter {
   constructor(host, port, keyLocation = './db/keys.json') {
     super();
@@ -37,6 +46,7 @@ class DiodeConnection extends EventEmitter {
     this.clientSockets = new Map(); // For BindPort
     this.connections = new Map(); // For PublishPort
     this.certPem = null;
+    this._serverEthAddress = null; // cache after first read
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
     
@@ -59,7 +69,7 @@ class DiodeConnection extends EventEmitter {
     this.retryTimeoutId = null;
     
     // Log the reconnection settings
-    logger.info(`Connection settings - Auto Reconnect: ${this.autoReconnect}, Max Retries: ${
+    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`);
 
@@ -71,7 +81,7 @@ class DiodeConnection extends EventEmitter {
     this.ticketUpdateTimer = null;
     
     // Log the ticket batching settings
-    logger.info(`Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
+    logger.info(() => `Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
   }
 
   connect() {
@@ -96,54 +106,59 @@ class DiodeConnection extends EventEmitter {
       };
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
-        logger.info('Connected to Diode.io server');
+        logger.info(() => 'Connected to Diode.io server');
         // Reset retry counter on successful connection
         this.retryCount = 0;
         // Set keep-alive to prevent connection timeout forever
         this.socket.setKeepAlive(true, 1500);
-  
+        this.socket.setNoDelay(true);
+        // Cache server address after handshake
+        try {
+          this._serverEthAddress = this.getServerEthereumAddress();
+        } catch (e) {
+          logger.warn(() => `Failed caching server address: ${e}`);
+        }
+        // Start periodic ticket updates now that we are fully connected
+        this._startTicketUpdateTimer();
         // Send the ticketv2 command
         try {
           const ticketCommand = await this.createTicketCommand();
           const response = await this.sendCommand(ticketCommand).catch(reject);
           resolve();
         } catch (error) {
-          logger.error(`Error sending ticket: ${error}`);
+          logger.error(() => `Error sending ticket: ${error}`);
           reject(error);
         }
       });
 
       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) {
-          logger.error(`Error handling data: ${error}`);
+          logger.error(() => `Error handling data: ${error}`);
         }
       });
 
-      // Start the periodic ticket update timer after successful connection
-      this.socket.on('connect', () => {
-        this._startTicketUpdateTimer();
-      });
+      // No-op: rely on secure handshake callback above for timers/caching
 
       this.socket.on('error', (err) => {
-        logger.error(`Connection error: ${err}`);
+        logger.error(() => `Connection error: ${err}`);
           reject(err);
       });
 
       this.socket.on('end', () => {
-        logger.info('Disconnected from server');
+        logger.info(() => 'Disconnected from server');
         this._handleDisconnect();
       });
 
       this.socket.on('close', (hadError) => {
-        logger.info(`Connection closed${hadError ? ' due to error' : ''}`);
+        logger.info(() => `Connection closed${hadError ? ' due to error' : ''}`);
         this._handleDisconnect();
       });
 
       this.socket.on('timeout', () => {
-        logger.warn('Connection timeout');
+        logger.warn(() => 'Connection timeout');
         this._handleDisconnect();
       });
     });
@@ -156,7 +171,7 @@ class DiodeConnection extends EventEmitter {
     this.retryCount++;
     
     if (this.maxRetries !== Infinity && this.retryCount > this.maxRetries) {
-      logger.error(`Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
+      logger.error(() => `Maximum reconnection attempts (${this.maxRetries}) reached. Giving up.`);
       this.emit('reconnect_failed');
       return;
     }
@@ -164,7 +179,7 @@ class DiodeConnection extends EventEmitter {
     // Calculate delay with exponential backoff
     const delay = Math.min(this.retryDelay * Math.pow(1.5, this.retryCount - 1), this.maxRetryDelay);
     
-    logger.info(`Reconnecting in ${delay}ms... (Attempt ${this.retryCount})`);
+    logger.info(() => `Reconnecting in ${delay}ms... (Attempt ${this.retryCount})`);
     this.emit('reconnecting', { attempt: this.retryCount, delay });
     
     this.retryTimeoutId = setTimeout(() => {
@@ -184,11 +199,11 @@ class DiodeConnection extends EventEmitter {
         .then(() => {
           this.isReconnecting = false;
           this.emit('reconnected');
-          logger.info('Successfully reconnected to Diode.io server');
+          logger.info(() => 'Successfully reconnected to Diode.io server');
         })
         .catch((err) => {
           this.isReconnecting = false;
-          logger.error(`Reconnection attempt failed: ${err}`);
+          logger.error(() => `Reconnection attempt failed: ${err}`);
         });
     }, delay);
   }
@@ -274,7 +289,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) {
@@ -291,8 +306,9 @@ class DiodeConnection extends EventEmitter {
       offset += 2 + length;
   
       try {
-        const decodedMessage = RLP.decode(Uint8Array.from(messageBuffer));
-        // logger.debug(`Decoded message: ${makeReadable(decodedMessage)}`);
+        // Avoid copying: pass Buffer directly to RLP.decode
+        const decodedMessage = RLP.decode(messageBuffer);
+        // logger.debug(() => `Decoded message: ${makeReadable(decodedMessage)}`);
     
         if (Array.isArray(decodedMessage) && decodedMessage.length > 1) {
           const requestIdRaw = decodedMessage[0];
@@ -302,8 +318,8 @@ class DiodeConnection extends EventEmitter {
           const requestId = parseRequestId(requestIdRaw);
     
           // Debug statements
-          logger.debug(`requestIdRaw: ${requestIdRaw}`);
-          logger.debug(`Parsed requestId: ${requestId}`);
+          logger.debug(() => `requestIdRaw: ${requestIdRaw}`);
+          logger.debug(() => `Parsed requestId: ${requestId}`);
     
           if (requestId !== null && this.pendingRequests.has(requestId)) {
             // This is a response to a pending request
@@ -311,14 +327,14 @@ class DiodeConnection extends EventEmitter {
             const responseRaw = responseData[0];
     
             // Debug statements
-            logger.debug(`responseTypeRaw: ${responseTypeRaw}`);
-            logger.debug(`Type of responseTypeRaw: ${typeof responseTypeRaw}`);
+            logger.debug(() => `responseTypeRaw: ${responseTypeRaw}`);
+            logger.debug(() => `Type of responseTypeRaw: ${typeof responseTypeRaw}`);
     
             // Parse responseType
             const responseType = parseResponseType(responseTypeRaw);
     
-            logger.debug(`Received response for requestId: ${requestId}`);
-            logger.debug(`Response Type: '${responseType}'`);
+            logger.debug(() => `Received response for requestId: ${requestId}`);
+            logger.debug(() => `Response Type: '${responseType}'`);
     
             const { resolve, reject } = this.pendingRequests.get(requestId);
             try{
@@ -344,20 +360,20 @@ class DiodeConnection extends EventEmitter {
                 resolve(responseData);
               }
             } catch (error) {
-              logger.error(`Error handling response: ${error}`);
+              logger.error(() => `Error handling response: ${error}`);
             }
             this.pendingRequests.delete(requestId);
           } else {
             // This is an unsolicited message
-            logger.debug(`Received unsolicited message`);
+            logger.debug(() => `Received unsolicited message`);
             this.emit('unsolicited', decodedMessage);
           }
         } else {
           // Invalid message format
-          logger.error(`Invalid message format: ${makeReadable(decodedMessage)}`);
+          logger.error(() => `Invalid message format: ${makeReadable(decodedMessage)}`);
         }
       } catch (error) {
-        logger.error(`Error decoding message: ${error}`);
+        logger.error(() => `Error decoding message: ${error}`);
       }
     }
     
@@ -392,21 +408,21 @@ class DiodeConnection extends EventEmitter {
         const requestId = this._getNextRequestId();
         // Build the message as [requestId, [commandArray]]
         const commandWithId = [requestId, commandArray];
-  
+
         // Store the promise callbacks to resolve/reject later
         this.pendingRequests.set(requestId, { resolve, reject });
-  
+
         const commandBuffer = RLP.encode(commandWithId);
-        const byteLength = Buffer.byteLength(commandBuffer);
-  
+        const byteLength = commandBuffer.length; // Buffer/Uint8Array length is bytes
+
         // Create a 2-byte length buffer
         const lengthBuffer = Buffer.alloc(2);
         lengthBuffer.writeUInt16BE(byteLength, 0);
-  
+
         const message = Buffer.concat([lengthBuffer, commandBuffer]);
   
-        logger.debug(`Sending command with requestId ${requestId}: ${commandArray}`);
-        // logger.debug(`Command buffer: ${message.toString('hex')}`);
+        logger.debug(() => `Sending command with requestId ${requestId}: ${commandArray}`);
+        // logger.debug(() => `Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
       }).catch(reject);
@@ -419,23 +435,24 @@ class DiodeConnection extends EventEmitter {
         const requestId = sessionId;
         // Build the message as [requestId, [commandArray]]
         const commandWithId = [requestId, commandArray];
-  
+
         // Store the promise callbacks to resolve/reject later
         this.pendingRequests.set(requestId, { resolve, reject });
-  
+
         const commandBuffer = RLP.encode(commandWithId);
-        const byteLength = Buffer.byteLength(commandBuffer);
-  
+        const byteLength = commandBuffer.length; // Buffer/Uint8Array length is bytes
+
         // Create a 2-byte length buffer
         const lengthBuffer = Buffer.alloc(2);
         lengthBuffer.writeUInt16BE(byteLength, 0);
-  
+
         const message = Buffer.concat([lengthBuffer, commandBuffer]);
   
-        logger.debug(`Sending command with requestId ${requestId}: ${commandArray}`);
-        // logger.debug(`Command buffer: ${message.toString('hex')}`);
+        logger.debug(() => `Sending command with requestId ${requestId}: ${commandArray}`);
+        // logger.debug(() => `Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
+        resolve();
       }).catch(reject);
     });
   }
@@ -452,13 +469,16 @@ class DiodeConnection extends EventEmitter {
 
       return address;
     } catch (error) {
-      logger.error(`Error extracting Ethereum address: ${error}`);
+      logger.error(() => `Error extracting Ethereum address: ${error}`);
       throw error;
     }
   }
   
   getServerEthereumAddress() {
     try {
+      if (this._serverEthAddress) {
+        return this._serverEthAddress;
+      }
       const serverCert = this.socket.getPeerCertificate(true);
       if (!serverCert.raw) {
         throw new Error('Failed to get server certificate.');
@@ -468,14 +488,14 @@ class DiodeConnection extends EventEmitter {
         ? serverCert.pubkey
         : Buffer.from(serverCert.pubkey);
 
-      logger.debug(`Public key Server: ${publicKeyBuffer.toString('hex')}`);
+      logger.debug(() => `Public key Server: ${publicKeyBuffer.toString('hex')}`);
 
       const addressBuffer = ethUtil.pubToAddress(publicKeyBuffer, true);
       const address = '0x' + addressBuffer.toString('hex');
-
-      return address;
+      this._serverEthAddress = address;
+      return this._serverEthAddress;
     } catch (error) {
-      logger.error(`Error extracting server Ethereum address: ${error}`);
+      logger.error(() => `Error extracting server Ethereum address: ${error}`);
       throw error;
     }
   }
@@ -488,13 +508,12 @@ class DiodeConnection extends EventEmitter {
       const privateKeyBytes = Buffer.from(privateKeyHex, 'hex');
       return privateKeyBytes;
     } catch (error) {
-      logger.error(`Error extracting private key: ${error}`);
+      logger.error(() => `Error extracting private key: ${error}`);
       throw error;
     }
   }
 
   async createTicketSignature(serverIdBuffer, totalConnections, totalBytes, localAddress, epoch) { 
-    this.getEthereumAddress()
     const chainId = 1284;
     const fleetContractBuffer = ethUtil.toBuffer('0x6000000000000000000000000000000000000000'); // 20-byte Buffer
   
@@ -512,23 +531,25 @@ class DiodeConnection extends EventEmitter {
       ethUtil.setLengthLeft(localAddressHash, 32),
     ];
 
-    // Convert each element in dataToSign to bytes32 and concatenate them
-    const encodedData = Buffer.concat(dataToSign.map(item => abi.rawEncode(['bytes32'], [item])));
+    // Elements are already bytes32; concatenate directly to avoid ABI overhead
+    const encodedData = Buffer.concat(dataToSign);
 
-    logger.debug(`Encoded data: ${encodedData.toString('hex')}`);
+    logger.debug(() => `Encoded data: ${encodedData.toString('hex')}`);
 
-    logger.debug(`Data to sign: ${makeReadable(dataToSign)}`);
+    logger.debug(() => `Data to sign: ${makeReadable(dataToSign)}`);
   
   
     // Sign the data
     const privateKey = this.getPrivateKey();
-    const msgHash = ethUtil.keccak256(encodedData);
-    logger.debug(`Message hash: ${msgHash.toString('hex')}`);
+    const msgHash = nativeKeccak
+      ? nativeKeccak('keccak256').update(encodedData).digest()
+      : ethUtil.keccak256(encodedData);
+    logger.debug(() => `Message hash: ${msgHash.toString('hex')}`);
     const signature = secp256k1.ecdsaSign(msgHash, privateKey);
-    logger.debug(`Signature: ${signature.signature.toString('hex')}`);
+    logger.debug(() => `Signature: ${signature.signature.toString('hex')}`);
     
     const signatureBuffer = Buffer.concat([
-      ethUtil.toBuffer([signature.recid]),
+      Buffer.from([signature.recid]),
       signature.signature
     ]);
 
@@ -559,7 +580,7 @@ class DiodeConnection extends EventEmitter {
       localAddress,
       epoch
     );
-    logger.debug(`Signature hex: ${signature.toString('hex')}`);
+    logger.debug(() => `Signature hex: ${signature.toString('hex')}`);
 
   
     // Construct the ticket command
@@ -650,7 +671,7 @@ class DiodeConnection extends EventEmitter {
       
       try {
       if (this.accumulatedBytes > 0 || force) {
-        logger.debug(`Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
+        logger.debug(() => `Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
         const ticketCommand = await this.createTicketCommand();
         await this.sendCommand(ticketCommand);
         
@@ -659,7 +680,7 @@ class DiodeConnection extends EventEmitter {
         this.lastTicketUpdate = Date.now();
       }
       } catch (error) {
-      logger.error(`Error updating ticket: ${error}`);
+      logger.error(() => `Error updating ticket: ${error}`);
       }
     }
     
@@ -687,7 +708,7 @@ class DiodeConnection extends EventEmitter {
       this.ticketUpdateInterval = options.interval;
     }
     
-    logger.info(`Updated ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
+    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) {