diodejs 0.2.2 → 0.4.0

package/connection.js

@@ -3,7 +3,7 @@ const tls = require('tls');
 const fs = require('fs');
 const { RLP } = require('@ethereumjs/rlp');
 const EventEmitter = require('events');
-const { makeReadable, parseRequestId, parseResponseType, parseReason, generateCert, ensureDirectoryExistence, loadOrGenerateKeyPair } = require('./utils');
+const { makeReadable, parseRequestId, parseResponseType, parseReason, parseUInt, generateCert, ensureDirectoryExistence, loadOrGenerateKeyPair, toBufferView } = require('./utils');
 const { Buffer } = require('buffer'); // Import Buffer
 const asn1 = require('asn1.js');
 const secp256k1 = require('secp256k1');
@@ -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,8 @@ 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
+    this.localAddressProvider = null;
     // Load or generate keypair
     this.keyPair = loadOrGenerateKeyPair(this.keyLocation);
     
@@ -59,7 +70,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 +82,13 @@ 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`);
+
+    // Handle server ticket requests on the API socket
+    this._onUnsolicited = (message) => {
+      this._handleUnsolicitedMessage(message);
+    };
+    this.on('unsolicited', this._onUnsolicited);
   }
 
   connect() {
@@ -96,54 +113,60 @@ class DiodeConnection extends EventEmitter {
       };
 
       this.socket = tls.connect(this.port, this.host, options, async () => {
-        logger.info('Connected to Diode.io server');
+        const relayHost = this.getServerRelayHost();
+        const relayPort = (this.socket && this.socket.remotePort) ? this.socket.remotePort : this.port;
+        logger.info(() => `Connected to Diode relay ${relayHost}:${relayPort}`);
         // 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
+        const cachedServerAddress = await this._waitForServerEthereumAddress();
+        if (cachedServerAddress) {
+          this._serverEthAddress = cachedServerAddress;
+        }
+        // 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 +179,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 +187,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 +207,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);
   }
@@ -254,6 +277,12 @@ class DiodeConnection extends EventEmitter {
     return this;
   }
 
+  // Optional provider for LocalAddr ticket hint (Buffer or string)
+  setLocalAddressProvider(provider) {
+    this.localAddressProvider = typeof provider === 'function' ? provider : null;
+    return this;
+  }
+
   // Update close method to prevent reconnection when intentionally closing
   close() {
     if (this.ticketUpdateTimer) {
@@ -274,7 +303,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 +320,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 +332,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 +341,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 +374,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}`);
       }
     }
     
@@ -366,6 +396,34 @@ class DiodeConnection extends EventEmitter {
     this.receiveBuffer = this.receiveBuffer.slice(offset);
   }
 
+  _handleUnsolicitedMessage(message) {
+    if (!Array.isArray(message) || message.length < 2) return;
+    const messageContent = message[1];
+    if (!Array.isArray(messageContent) || messageContent.length < 1) return;
+
+    const messageTypeRaw = messageContent[0];
+    const messageType = toBufferView(messageTypeRaw).toString('utf8');
+
+    if (messageType === 'ticket_request') {
+      const deviceUsageRaw = messageContent[1];
+      const deviceUsage = parseUInt(deviceUsageRaw);
+      if (typeof deviceUsage === 'number' && deviceUsage > this.totalBytes) {
+        this.totalBytes = deviceUsage;
+      }
+
+      // Send a fresh ticket promptly to avoid disconnect
+      this.createTicketCommand()
+        .then((ticketCommand) => this.sendCommand(ticketCommand))
+        .then(() => {
+          this.accumulatedBytes = 0;
+          this.lastTicketUpdate = Date.now();
+        })
+        .catch((error) => {
+          logger.error(() => `Error handling ticket_request: ${error}`);
+        });
+    }
+  }
+
   fixResponse(response) {
     /* response is : 
     [
@@ -392,21 +450,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 +477,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,32 +511,70 @@ 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() {
+  getServerEthereumAddress(quiet = false) {
     try {
+      if (this._serverEthAddress) {
+        return this._serverEthAddress;
+      }
       const serverCert = this.socket.getPeerCertificate(true);
       if (!serverCert.raw) {
-        throw new Error('Failed to get server certificate.');
+        const err = new Error('Failed to get server certificate.');
+        if (!quiet) {
+          throw err;
+        }
+        return null;
       }
 
       const publicKeyBuffer = Buffer.isBuffer(serverCert.pubkey)
         ? 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');
+      this._serverEthAddress = address;
+      return this._serverEthAddress;
+    } catch (error) {
+      if (!quiet) {
+        logger.error(() => `Error extracting server Ethereum address: ${error}`);
+        throw error;
+      }
+      return null;
+    }
+  }
 
+  getServerRelayHost() {
+    if (this.socket && this.socket.remoteAddress) {
+      const address = this.socket.remoteAddress;
+      if (address.startsWith('::ffff:')) {
+        return address.slice(7);
+      }
+      if (address.includes(':')) {
+        return this.host;
+      }
       return address;
-    } catch (error) {
-      logger.error(`Error extracting server Ethereum address: ${error}`);
-      throw error;
     }
+    return this.host;
+  }
+
+  async _waitForServerEthereumAddress(options = {}) {
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 2000;
+    const intervalMs = Number.isFinite(options.intervalMs) ? options.intervalMs : 50;
+    const start = Date.now();
+    let address = this.getServerEthereumAddress(true);
+    if (address) return address;
+    while (Date.now() - start < timeoutMs) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      address = this.getServerEthereumAddress(true);
+      if (address) return address;
+    }
+    return null;
   }
 
   // Method to extract private key bytes from keyPair
@@ -488,18 +585,19 @@ 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
   
-    // Hash of localAddress (empty string)
-    const localAddressHash = crypto.createHash('sha256').update(Buffer.from(localAddress, 'utf8')).digest();
+    const localAddressBytes = Buffer.isBuffer(localAddress) || localAddress instanceof Uint8Array
+      ? toBufferView(localAddress)
+      : Buffer.from(localAddress || '', 'utf8');
+    const localAddressHash = crypto.createHash('sha256').update(localAddressBytes).digest();
   
     // Data to sign
     const dataToSign = [
@@ -512,23 +610,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
     ]);
 
@@ -538,7 +638,18 @@ class DiodeConnection extends EventEmitter {
   async createTicketCommand() {
     const chainId = 1284;
     const fleetContract = ethUtil.toBuffer('0x6000000000000000000000000000000000000000')
-    const localAddress = 'test2'; // Always empty string
+    let localAddress = '';
+    if (typeof this.localAddressProvider === 'function') {
+      try {
+        localAddress = this.localAddressProvider();
+      } catch (error) {
+        logger.warn(() => `Failed to get local address hint: ${error}`);
+        localAddress = '';
+      }
+    }
+    if (localAddress === null || localAddress === undefined) {
+      localAddress = '';
+    }
   
     // Increment totalConnections
     this.totalConnections += 1;
@@ -548,7 +659,10 @@ class DiodeConnection extends EventEmitter {
     const totalBytes = this.totalBytes;
   
     // Get server Ethereum address as Buffer
-    const serverIdBuffer = this.getServerEthereumAddress();
+    const serverIdBuffer = await this._waitForServerEthereumAddress();
+    if (!serverIdBuffer) {
+      throw new Error('Failed to get server certificate.');
+    }
 
     // Get epoch
     const epoch = await this.RPC.getEpoch();
@@ -559,7 +673,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 +764,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 +773,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 +801,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) {

package/examples/RPCTest.js

@@ -1,14 +1,16 @@
-const { DiodeConnection, DiodeRPC } = require('../index');
+const { DiodeClientManager, DiodeRPC } = require('../index');
 const { makeReadable } = require('../utils');
 
 async function main() {
-  const host = 'us2.prenet.diode.io';
-  const port = 41046;
   const keyLocation = './db/keys.json';
 
-  const connection = new DiodeConnection(host, port, keyLocation);
-  await connection.connect();
-  const rpc = connection.RPC;
+  const client = new DiodeClientManager({ keyLocation });
+  await client.connect();
+  const [connection] = client.getConnections();
+  if (!connection) {
+    throw new Error('No relay connection available');
+  }
+  const rpc = connection.RPC || new DiodeRPC(connection);
 
   try {
     const address = connection.getEthereumAddress();
@@ -22,7 +24,7 @@ async function main() {
   } catch (error) {
     console.error('RPC Error:', error);
   } finally {
-    connection.close();
+    client.close();
   }
 }
 

package/examples/nativeBindTest.js

@@ -0,0 +1,55 @@
+const { KEYUTIL } = require('jsrsasign');
+const { DiodeClientManager, BindPort } = require('../index');
+
+function printPublicKey(connection) {
+  try {
+    const pem = KEYUTIL.getPEM(connection.keyPair.pubKeyObj, 'PKCS8PUB');
+    console.log('Public key (PEM):');
+    console.log(pem);
+  } catch (error) {
+    console.error('Failed to print public key:', error);
+  }
+  try {
+    console.log('Ethereum address:', connection.getEthereumAddress());
+  } catch (error) {
+    console.error('Failed to print address:', error);
+  }
+}
+
+async function main() {
+  const keyLocation = './db/keys2.json';
+
+  const deviceIdHex = process.env.DIODE_TARGET_DEVICE || process.argv[2] || '0x4632c04cf8c44a586554951e7de03ca2bd3e8f1c'; // Replace with actual device
+
+  const client = new DiodeClientManager({keyLocation });
+  await client.connect();
+  const [connection] = client.getConnections();
+  if (!connection) {
+    throw new Error('No relay connection available');
+  }
+
+  printPublicKey(connection);
+
+  const portsConfig = {
+    3005: {
+      targetPort: 8089,
+      deviceIdHex,
+      protocol: 'tcp',
+      transport: 'native'
+    },
+    3006: {
+      targetPort: 8090,
+      deviceIdHex,
+      protocol: 'udp',
+      transport: 'native',
+      flags: 'rwu'
+    }
+  };
+
+  const portForward = new BindPort(client, portsConfig);
+  portForward.bind();
+
+  console.log('Native bind ports active:', Object.keys(portsConfig).join(', '));
+}
+
+main().catch(console.error);