diodejs 0.4.4 → 0.4.5

package/bindPort.js

@@ -403,7 +403,7 @@ class BindPort {
           logger.info(() => `Port closed for ref: ${dataRef.toString('hex')}`);
         }
       } else {
-        if (messageType != 'portopen' && messageType != 'portopen2' && messageType != 'ticket_request') {
+        if (messageType != 'portopen' && messageType != 'portopen2' && messageType != 'ticket_request' && messageType != 'response') {
           logger.warn(() => `Unknown unsolicited message type: ${messageType}`);
         }
       }
@@ -904,9 +904,19 @@ class BindPort {
           connection.addClientSocket(ref, clientSocket);
           
           // Handle data from client to device
-          clientSocket.on('data', async (data) => {
+          clientSocket.on('data', (data) => {
+            clientSocket.pause();
             try {
-              await rpc.portSend(ref, data);
+              rpc.portSend(ref, data)
+                .then(() => {
+                  if (!clientSocket.destroyed) {
+                    clientSocket.resume();
+                  }
+                })
+                .catch((error) => {
+                  logger.error(() => `Error sending data to device: ${error}`);
+                  clientSocket.destroy();
+                });
             } catch (error) {
               logger.error(() => `Error sending data to device: ${error}`);
               clientSocket.destroy();

package/connection.js

@@ -91,9 +91,13 @@ class DiodeConnection extends EventEmitter {
     // 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.ticketUpdateThreshold = parseInt(process.env.DIODE_TICKET_BYTES_THRESHOLD, 10) || 4 * 1024 * 1024; // 4MB default
     this.ticketUpdateInterval = parseInt(process.env.DIODE_TICKET_UPDATE_INTERVAL, 10) || 30000; // 30 seconds default
     this.ticketUpdateTimer = null;
+    this.ticketUpdateInFlight = false;
+    this.pendingTicketUpdateForce = false;
+    this.lastAcceptedTicketBytes = 0;
+    this.lastRelayMeasuredBytes = 0;
     
     // Log the ticket batching settings
     logger.info(() => `Ticket batching settings - Bytes Threshold: ${this.ticketUpdateThreshold} bytes, Update Interval: ${this.ticketUpdateInterval}ms`);
@@ -144,6 +148,7 @@ class DiodeConnection extends EventEmitter {
         this._startTicketUpdateTimer();
         // Send the ticketv2 command
         try {
+          await this._syncMeasuredBytesWithRelay();
           const ticketCommand = await this.createTicketCommand();
           const response = await this.sendCommand(ticketCommand).catch(reject);
           resolve();
@@ -155,6 +160,7 @@ class DiodeConnection extends EventEmitter {
 
       this.socket.on('data', (data) => {
         // logger.debug(() => `Received data: ${data.toString('hex')}`);
+        this._recordTrafficBytes(data.length);
         try {
           this._handleData(data);
         } catch (error) {
@@ -371,17 +377,35 @@ class DiodeConnection extends EventEmitter {
             logger.debug(() => `Received response for requestId: ${requestId}`);
             logger.debug(() => `Response Type: '${responseType}'`);
     
-            const { resolve, reject } = this.pendingRequests.get(requestId);
+            const pending = this.pendingRequests.get(requestId);
+            const { resolve, reject } = pending;
             try{
               if (responseType === 'response') {
                 if (!Array.isArray(responseRaw) && makeReadable(responseRaw) === 'too_low') {
-                  this.fixResponse(responseData);
-                  // Re-send the ticket command
-                  this.createTicketCommand().then((ticketCommand) => {
-                    this.sendCommand(ticketCommand).then(resolve).catch(reject);
-                  }).catch(reject);
+                  const originalCommand = pending && pending.commandArray;
+                  const retryCount = pending && pending.ticketRetryCount ? pending.ticketRetryCount : 0;
+                  const isTicketCommand = Array.isArray(originalCommand) &&
+                    (originalCommand[0] === 'ticket' || originalCommand[0] === 'ticketv2');
+
+                  if (isTicketCommand && retryCount < 1) {
+                    this.fixResponse(responseData);
+                    this.pendingRequests.delete(requestId);
+                    this._syncMeasuredBytesWithRelay()
+                      .catch((error) => {
+                        logger.debug(() => `Unable to sync relay measured bytes after too_low: ${error}`);
+                      })
+                      .then(() => this.createTicketCommand())
+                      .then((ticketCommand) => this.sendCommand(ticketCommand, { ticketRetryCount: retryCount + 1 }))
+                      .then(resolve)
+                      .catch(reject);
+                    return;
+                  }
+                  this._recordTicketResponse(originalCommand, responseData);
                   resolve(responseData);
+                  this.pendingRequests.delete(requestId);
+                  return;
                 }
+                this._recordTicketResponse(pending && pending.commandArray, responseData);
                 resolve(responseData);
               } else if (responseType === 'error') {
                 if (responseData.length > 1) {
@@ -433,11 +457,23 @@ class DiodeConnection extends EventEmitter {
       }
 
       // Send a fresh ticket promptly to avoid disconnect
-      this.createTicketCommand()
-        .then((ticketCommand) => this.sendCommand(ticketCommand))
-        .then(() => {
-          this.accumulatedBytes = 0;
-          this.lastTicketUpdate = Date.now();
+      this._syncMeasuredBytesWithRelay()
+        .catch((error) => {
+          logger.debug(() => `Unable to sync relay measured bytes for ticket_request: ${error}`);
+        })
+        .then(() => this.createTicketCommand())
+        .then((ticketCommand) => {
+          const ticketTotalBytes = parseUInt(ticketCommand[5]);
+          return this.sendCommand(ticketCommand).then((responseData) => ({ responseData, ticketTotalBytes }));
+        })
+        .then(({ responseData, ticketTotalBytes }) => {
+          const status = responseData && responseData[0] !== undefined ? parseResponseType(responseData[0]) : '';
+          if (status === 'thanks!') {
+            if (Number.isFinite(ticketTotalBytes)) {
+              this.accumulatedBytes = Math.max(0, this.totalBytes - ticketTotalBytes);
+            }
+            this.lastTicketUpdate = Date.now();
+          }
         })
         .catch((error) => {
           logger.error(() => `Error handling ticket_request: ${error}`);
@@ -446,26 +482,141 @@ class DiodeConnection extends EventEmitter {
   }
 
   fixResponse(response) {
-    /* response is : 
-    [
-    'too_low',
-    1284,
-    666,
-    11,
-    135591,
-    'test',
-    '0x01eb1726dd7286d2dab222ea5dfef7c820cd01c30936240f5780a6e468e731f3b55d4c963b3eb768663263b396555aa52be49d7d3ae2a9173732fa410ad46434f3'
-  ]
-    [3] is last totalConnections
-    [4] is last totalBytes
+    /*
+      ticketv2 too_low responses are:
+      [
+        'too_low',
+        chain_id,
+        epoch,
+        last_total_connections,
+        last_total_bytes,
+        local_address,
+        device_signature
+      ]
+      The byte value is the relay's last accepted paid floor. The live
+      unpaid measurement still comes from the relay "bytes" command.
     */
-    const totalConnectionsBuffer = Buffer.from(response[3]);
-    const totalBytesBuffer = Buffer.from(response[4]);
-    this.totalConnections = parseInt(totalConnectionsBuffer.readUIntBE(0, totalConnectionsBuffer.length), 10) +1;
-    this.totalBytes = parseInt(totalBytesBuffer.readUIntBE(0, totalBytesBuffer.length), 10) + 128000;
+    const lastTicket = this._parseTooLowTicketSummary(response);
+    if (Number.isFinite(lastTicket.totalConnections)) {
+      this.totalConnections = Math.max(this.totalConnections, lastTicket.totalConnections);
+    }
+    if (Number.isFinite(lastTicket.totalBytes)) {
+      this.lastAcceptedTicketBytes = Math.max(this.lastAcceptedTicketBytes, lastTicket.totalBytes);
+      const relayMeasuredBytes = Number.isFinite(this.lastRelayMeasuredBytes) ? this.lastRelayMeasuredBytes : 0;
+      const pendingBytes = Math.max(this.accumulatedBytes, relayMeasuredBytes, 0);
+      this.totalBytes = Math.max(this.totalBytes, lastTicket.totalBytes + pendingBytes + 1024);
+      this.accumulatedBytes = Math.max(this.accumulatedBytes, this.totalBytes - lastTicket.totalBytes);
+    }
+  }
+
+  _parseTooLowTicketSummary(response) {
+    if (!Array.isArray(response)) {
+      return { totalConnections: null, totalBytes: null };
+    }
+
+    const firstItem = response[0];
+    const firstItemType = typeof firstItem === 'string' || Buffer.isBuffer(firstItem) || firstItem instanceof Uint8Array
+      ? parseResponseType(firstItem)
+      : '';
+    let normalized = response;
+    if (firstItemType === 'response') {
+      const secondItem = response[1];
+      const secondItemType = typeof secondItem === 'string' || Buffer.isBuffer(secondItem) || secondItem instanceof Uint8Array
+        ? parseResponseType(secondItem)
+        : '';
+      normalized = secondItemType === 'too_low' ? response.slice(2) : response;
+    } else if (firstItemType === 'too_low') {
+      normalized = response.slice(1);
+    }
+
+    if (normalized.length >= 6) {
+      return {
+        version: 2,
+        chainId: parseUInt(normalized[0]),
+        epoch: parseUInt(normalized[1]),
+        totalConnections: parseUInt(normalized[2]),
+        totalBytes: parseUInt(normalized[3]),
+        localAddress: normalized[4],
+        deviceSignature: normalized[5],
+      };
+    }
+
+    if (normalized.length >= 5) {
+      return {
+        version: 1,
+        blockHash: normalized[0],
+        totalConnections: parseUInt(normalized[1]),
+        totalBytes: parseUInt(normalized[2]),
+        localAddress: normalized[3],
+        deviceSignature: normalized[4],
+      };
+    }
+
+    return { totalConnections: null, totalBytes: null };
+  }
+
+  _isTicketCommand(commandArray) {
+    return Array.isArray(commandArray) &&
+      (commandArray[0] === 'ticket' || commandArray[0] === 'ticketv2');
+  }
+
+  _ticketTotalBytes(commandArray) {
+    if (!this._isTicketCommand(commandArray)) return null;
+    const index = commandArray[0] === 'ticketv2' ? 5 : 4;
+    return parseUInt(commandArray[index]);
+  }
+
+  _recordTicketResponse(commandArray, responseData) {
+    if (!this._isTicketCommand(commandArray) || !Array.isArray(responseData)) return;
+    const status = responseData[0] !== undefined ? parseResponseType(responseData[0]) : '';
+    if (status !== 'thanks!') return;
+    const ticketTotalBytes = this._ticketTotalBytes(commandArray);
+    if (!Number.isFinite(ticketTotalBytes)) return;
+    this.lastAcceptedTicketBytes = Math.max(this.lastAcceptedTicketBytes, ticketTotalBytes);
+    this.accumulatedBytes = Math.max(0, this.totalBytes - ticketTotalBytes);
+    this.lastTicketUpdate = Date.now();
+  }
+
+  _recordTrafficBytes(bytesCount) {
+    if (!Number.isFinite(bytesCount) || bytesCount <= 0) return;
+    this.totalBytes += bytesCount;
+    this.accumulatedBytes += bytesCount;
+
+    if (this.accumulatedBytes >= this.ticketUpdateThreshold) {
+      this._updateTicketIfNeeded();
+    }
+  }
+
+  _parseRelaySignedInt(valueRaw) {
+    const encoded = parseUInt(valueRaw);
+    if (!Number.isFinite(encoded)) return null;
+    if (encoded % 2 === 0) return encoded / 2;
+    return -((encoded - 1) / 2);
+  }
+
+  async _syncMeasuredBytesWithRelay() {
+    if (!this.socket || this.socket.destroyed) return null;
+    const responseData = await this.sendCommand(['bytes']);
+    const measuredBytes = responseData && responseData[0] !== undefined
+      ? this._parseRelaySignedInt(responseData[0])
+      : null;
+    if (!Number.isFinite(measuredBytes) || measuredBytes <= 0) {
+      return measuredBytes;
+    }
+
+    this.lastRelayMeasuredBytes = measuredBytes;
+    const baseBytes = Number.isFinite(this.lastAcceptedTicketBytes) && this.lastAcceptedTicketBytes > 0
+      ? this.lastAcceptedTicketBytes
+      : 128000;
+    const targetTotalBytes = baseBytes + measuredBytes + 1024;
+    if (targetTotalBytes > this.totalBytes) {
+      this.totalBytes = targetTotalBytes;
+      this.accumulatedBytes = Math.max(this.accumulatedBytes, this.totalBytes - baseBytes);
+    }
+    return measuredBytes;
   }
 
-  sendCommand(commandArray) {
+  sendCommand(commandArray, options = {}) {
     return new Promise((resolve, reject) => {
       this._ensureConnected().then(() => {
         const requestId = this._getNextRequestId();
@@ -473,7 +624,12 @@ class DiodeConnection extends EventEmitter {
         const commandWithId = [requestId, commandArray];
 
         // Store the promise callbacks to resolve/reject later
-        this.pendingRequests.set(requestId, { resolve, reject });
+        this.pendingRequests.set(requestId, {
+          resolve,
+          reject,
+          commandArray,
+          ticketRetryCount: options.ticketRetryCount || 0,
+        });
 
         const commandBuffer = RLP.encode(commandWithId);
         const byteLength = commandBuffer.length; // Buffer/Uint8Array length is bytes
@@ -488,6 +644,7 @@ class DiodeConnection extends EventEmitter {
         // logger.debug(() => `Command buffer: ${message.toString('hex')}`);
   
         this.socket.write(message);
+        this._recordTrafficBytes(message.length);
       }).catch(reject);
     });
   }
@@ -499,9 +656,6 @@ class DiodeConnection extends EventEmitter {
         // 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 = commandBuffer.length; // Buffer/Uint8Array length is bytes
 
@@ -514,8 +668,8 @@ class DiodeConnection extends EventEmitter {
         logger.debug(() => `Sending command with requestId ${requestId}: ${commandArray}`);
         // logger.debug(() => `Command buffer: ${message.toString('hex')}`);
   
-        this.socket.write(message);
-        resolve();
+        this.socket.write(message, resolve);
+        this._recordTrafficBytes(message.length);
       }).catch(reject);
     });
   }
@@ -765,7 +919,7 @@ class DiodeConnection extends EventEmitter {
     }
     
     this.ticketUpdateTimer = setTimeout(() => {
-      this._updateTicketIfNeeded(true);
+      this._updateTicketIfNeeded();
     }, this.ticketUpdateInterval);
   }
 
@@ -775,6 +929,11 @@ class DiodeConnection extends EventEmitter {
     if (!this.socket || this.socket.destroyed) {
       return;
     }
+
+    if (this.ticketUpdateInFlight) {
+      this.pendingTicketUpdateForce = this.pendingTicketUpdateForce || force;
+      return;
+    }
     
     const timeSinceLastUpdate = Date.now() - this.lastTicketUpdate;
     
@@ -783,18 +942,38 @@ class DiodeConnection extends EventEmitter {
       (this.accumulatedBytes >= this.ticketUpdateThreshold || 
       timeSinceLastUpdate >= this.ticketUpdateInterval))) {
       
+      this.ticketUpdateInFlight = true;
+      let accepted = false;
       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();
-      }
+        if (this.accumulatedBytes > 0 || force) {
+          logger.debug(() => `Updating ticket: accumulated ${this.accumulatedBytes} bytes, ${timeSinceLastUpdate}ms since last update`);
+          await this._syncMeasuredBytesWithRelay().catch((error) => {
+            logger.debug(() => `Unable to sync relay measured bytes before ticket update: ${error}`);
+          });
+          const ticketCommand = await this.createTicketCommand();
+          const ticketTotalBytes = parseUInt(ticketCommand[5]);
+          const responseData = await this.sendCommand(ticketCommand);
+          const status = responseData && responseData[0] !== undefined ? parseResponseType(responseData[0]) : '';
+          if (status === 'thanks!') {
+            accepted = true;
+            if (Number.isFinite(ticketTotalBytes)) {
+              this.accumulatedBytes = Math.max(0, this.totalBytes - ticketTotalBytes);
+            }
+            this.lastTicketUpdate = Date.now();
+          }
+        }
       } catch (error) {
-      logger.error(() => `Error updating ticket: ${error}`);
+        logger.error(() => `Error updating ticket: ${error}`);
+      } finally {
+        this.ticketUpdateInFlight = false;
+      }
+
+      if (accepted && (this.pendingTicketUpdateForce || this.accumulatedBytes >= this.ticketUpdateThreshold)) {
+        const pendingForce = this.pendingTicketUpdateForce;
+        this.pendingTicketUpdateForce = false;
+        setImmediate(() => this._updateTicketIfNeeded(pendingForce));
+      } else {
+        this.pendingTicketUpdateForce = false;
       }
     }
     
@@ -804,13 +983,7 @@ class DiodeConnection extends EventEmitter {
 
   // 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();
-    }
+    this._recordTrafficBytes(bytesCount);
   }
 
   // Method to set ticket batching options

package/package.json

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

@@ -231,7 +231,7 @@ class PublishPort extends EventEmitter {
       } else if (messageType === 'portclose') {
         this.handlePortClose(sessionIdRaw, messageContent, connection);
       } else {
-        if (messageType !== 'ticket_request') {
+        if (messageType !== 'ticket_request' && messageType !== 'response') {
           logger.warn(() => `Unknown unsolicited message type: ${messageType}`);
         }
       }
@@ -736,7 +736,17 @@ class PublishPort extends EventEmitter {
     } else {
       localSocket.on('data', (data) => {
         // When data is received from the local service, send it back via Diode
-        rpc.portSend(ref, data);
+        localSocket.pause();
+        rpc.portSend(ref, data)
+          .then(() => {
+            if (!localSocket.destroyed) {
+              localSocket.resume();
+            }
+          })
+          .catch((error) => {
+            logger.error(() => `Error sending data to device: ${error}`);
+            localSocket.destroy();
+          });
       });
 
       localSocket.on('end', () => {

package/rpc.js

@@ -1,5 +1,12 @@
 //rpc.js
-const { makeReadable, parseRequestId, parseResponseType, parseReason, parseUInt, toBufferView } = require('./utils');
+const {
+  makeReadable,
+  parseRequestId,
+  parseResponseType,
+  parseReason,
+  parseUInt,
+  toBufferView,
+} = require('./utils');
 const logger = require('./logger');
 
 function decodeToken(value) {
@@ -89,6 +96,80 @@ class DiodeRPC {
         expiry: null,
       };
     }
+
+    async dioTraffic(options = {}) {
+      const chainId = options.chainId === undefined ? 1284 : options.chainId;
+      const params = options.epoch === undefined ? [chainId] : [chainId, options.epoch];
+
+      return this.nodeRpc('dio_traffic', params, options);
+    }
+
+    dio_traffic(options = {}) {
+      return this.dioTraffic(options);
+    }
+
+    async nodeRpc(method, params = [], options = {}) {
+      if (typeof fetch !== 'function') {
+        throw new Error('global fetch is required for node RPC calls');
+      }
+
+      const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+        ? Math.floor(options.timeoutMs)
+        : 30000;
+      const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+      const timer = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
+
+      try {
+        const response = await fetch(this._nodeRpcEndpoint(options), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: options.id || 1,
+            method,
+            params,
+          }),
+          signal: controller ? controller.signal : undefined,
+        });
+
+        let payload = {};
+        try {
+          payload = await response.json();
+        } catch (_) {
+          payload = {};
+        }
+
+        if (!response.ok || payload.error) {
+          const error = new Error(payload?.error?.message || `${method} failed with status ${response.status}`);
+          error.status = response.status;
+          error.response = payload;
+          throw error;
+        }
+
+        return payload.result;
+      } finally {
+        if (timer) {
+          clearTimeout(timer);
+        }
+      }
+    }
+
+    _nodeRpcEndpoint(options = {}) {
+      const protocol = options.protocol || 'https';
+      const rpcPort = Number.isFinite(options.rpcPort) && options.rpcPort > 0 ? options.rpcPort : 8443;
+      let host = options.host || '';
+      if (!host && this.connection) {
+        host = this.connection.host;
+      }
+      if (!host && this.connection && typeof this.connection.getServerRelayHost === 'function') {
+        host = this.connection.getServerRelayHost();
+      }
+      if (!host) {
+        throw new Error('No relay host available for node RPC call');
+      }
+      const formattedHost = host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
+      return `${protocol}://${formattedHost}:${rpcPort}/`;
+    }
   
     getBlockPeak() {
         return this.connection.sendCommand(['getblockpeak']).then((responseData) => {
@@ -223,10 +304,6 @@ class DiodeRPC {
       }
     
       async portSend(ref, data) {
-        // Update bytes count but don't update ticket yet
-        const bytesToSend = data.length;
-        this.connection.addBytes(bytesToSend);
-    
         // Maximum size that can be sent in a single message (less than 65535 to be safe)
         const MAX_CHUNK_SIZE = 65000;
         

package/test/bindPort.test.js

@@ -240,3 +240,50 @@ test('API bind closes ref when local TCP client disconnects after portopen retur
     server.close();
   }
 });
+
+test('API bind pauses local TCP socket while portSend is in flight', async () => {
+  const calls = [];
+  const send = deferred();
+  const ref = makeRef('12131415');
+  const relay = makeRelay('relay.example:41046', ref, calls);
+  const portSendCalls = [];
+  relay.RPC.portSend = async (...args) => {
+    portSendCalls.push(args);
+    return send.promise;
+  };
+  const manager = new FakeManager({
+    relays: [relay],
+    resolvedRelay: relay,
+    nearestRelay: relay,
+  });
+
+  const bind = new BindPort(manager, {
+    0: {
+      targetPort: 8088,
+      deviceIdHex: '8a72468957504d50247a260deb0218d504dd091b',
+      protocol: 'tcp',
+    }
+  });
+  bind.addPort(0, 8088, '8a72468957504d50247a260deb0218d504dd091b', 'tcp');
+  const server = bind.servers.get(0);
+
+  try {
+    await once(server, 'listening');
+    const client = net.connect(server.address().port, '127.0.0.1');
+    await once(client, 'connect');
+    await waitFor(() => relay.hasClientSocket(ref));
+
+    client.write(Buffer.from('hello'));
+    await waitFor(() => portSendCalls.length === 1);
+
+    const acceptedSocket = relay.getClientSocket(ref);
+    assert.equal(acceptedSocket.isPaused(), true);
+
+    send.resolve();
+    await waitFor(() => acceptedSocket.isPaused() === false);
+
+    client.destroy();
+  } finally {
+    server.close();
+  }
+});

package/test/connection.ticketRetry.test.js

@@ -0,0 +1,162 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { RLP } = require('@ethereumjs/rlp');
+
+const DiodeConnection = require('../connection');
+
+function makeConnection() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'diode-ticket-retry-test-'));
+  return new DiodeConnection('relay.example', 41046, path.join(tempDir, 'keys.json'));
+}
+
+function encodeResponse(requestId, response) {
+  const payload = RLP.encode([requestId, response]);
+  const length = Buffer.alloc(2);
+  length.writeUInt16BE(payload.length, 0);
+  return Buffer.concat([length, Buffer.from(payload)]);
+}
+
+function tooLowResponse(overrides = {}) {
+  const totalConnections = overrides.totalConnections === undefined ? 11 : overrides.totalConnections;
+  const totalBytes = overrides.totalBytes === undefined ? 135591 : overrides.totalBytes;
+
+  return [
+    'response',
+    'too_low',
+    1284,
+    687,
+    totalConnections,
+    totalBytes,
+    Buffer.from([0]),
+    Buffer.from([1]),
+  ];
+}
+
+test('ticket too_low response retries once with repaired ticket', async () => {
+  const connection = makeConnection();
+  let retryCount = 0;
+
+  connection.fixResponse = () => {};
+  connection.createTicketCommand = async () => ['ticketv2'];
+  connection.sendCommand = async (command, options) => {
+    retryCount += 1;
+    assert.deepEqual(command, ['ticketv2']);
+    assert.equal(options.ticketRetryCount, 1);
+    return ['thanks!', 1];
+  };
+
+  const resultPromise = new Promise((resolve, reject) => {
+    connection.pendingRequests.set(1, {
+      resolve,
+      reject,
+      commandArray: ['ticketv2'],
+      ticketRetryCount: 0,
+    });
+  });
+
+  connection._handleData(encodeResponse(1, tooLowResponse()));
+  const result = await resultPromise;
+
+  assert.deepEqual(result, ['thanks!', 1]);
+  assert.equal(retryCount, 1);
+});
+
+test('ticket too_low response does not retry recursively', async () => {
+  const connection = makeConnection();
+  let retryCount = 0;
+
+  connection.fixResponse = () => {};
+  connection.createTicketCommand = async () => {
+    retryCount += 1;
+    return ['ticketv2'];
+  };
+
+  const resultPromise = new Promise((resolve, reject) => {
+    connection.pendingRequests.set(1, {
+      resolve,
+      reject,
+      commandArray: ['ticketv2'],
+      ticketRetryCount: 1,
+    });
+  });
+
+  connection._handleData(encodeResponse(1, tooLowResponse()));
+  const result = await resultPromise;
+
+  assert.equal(retryCount, 0);
+  assert.equal(Buffer.from(result[0]).toString('utf8'), 'too_low');
+});
+
+test('session responses do not swallow later unsolicited messages on the same session', async () => {
+  const connection = makeConnection();
+  const writes = [];
+
+  connection._ensureConnected = async () => {};
+  connection.socket = {
+    write(message, callback) {
+      writes.push(message);
+      callback();
+    },
+  };
+
+  await connection.sendCommandWithSessionId(['response', Buffer.from([1]), 'ok'], 7);
+
+  assert.equal(connection.pendingRequests.has(7), false);
+  assert.equal(writes.length, 1);
+
+  const unsolicited = new Promise((resolve) => {
+    connection.once('unsolicited', resolve);
+  });
+  connection._handleData(encodeResponse(7, ['portsend', Buffer.from([1]), Buffer.from('hello')]));
+
+  const message = await unsolicited;
+  assert.equal(Buffer.from(message[0]).readUIntBE(0, Buffer.from(message[0]).length), 7);
+  assert.equal(Buffer.from(message[1][0]).toString('utf8'), 'portsend');
+});
+
+test('too_low repair does not reduce local byte counters', () => {
+  const connection = makeConnection();
+  connection.totalConnections = 40;
+  connection.totalBytes = 1304576;
+
+  connection.fixResponse(tooLowResponse());
+
+  assert.equal(connection.totalConnections, 40);
+  assert.equal(connection.totalBytes, 1304576);
+});
+
+test('too_low repair uses node-reported paid byte floor', () => {
+  const connection = makeConnection();
+  connection.totalConnections = 4;
+  connection.totalBytes = 128000;
+  connection.accumulatedBytes = 2048;
+  connection.lastRelayMeasuredBytes = 4096;
+
+  connection.fixResponse(tooLowResponse({
+    totalConnections: 7,
+    totalBytes: 135591,
+  }));
+
+  assert.equal(connection.totalConnections, 7);
+  assert.equal(connection.lastAcceptedTicketBytes, 135591);
+  assert.equal(connection.totalBytes, 140711);
+  assert.equal(connection.accumulatedBytes, 5120);
+});
+
+test('ticket update keeps accumulated bytes when ticket is rejected', async () => {
+  const connection = makeConnection();
+  connection.socket = { destroyed: false };
+  connection.accumulatedBytes = 1000;
+  connection.lastTicketUpdate = 123;
+  connection.createTicketCommand = async () => ['ticketv2'];
+  connection.sendCommand = async () => ['too_low'];
+  connection._startTicketUpdateTimer = () => {};
+
+  await connection._updateTicketIfNeeded(true);
+
+  assert.equal(connection.accumulatedBytes, 1000);
+  assert.equal(connection.lastTicketUpdate, 123);
+});

package/test/publishPort.test.js

@@ -15,10 +15,17 @@ class FakeStreamSocket extends EventEmitter {
     this.remoteAddress = undefined;
     this.remotePort = undefined;
     this.writes = [];
+    this.pauseCalls = 0;
+    this.resumeCalls = 0;
   }
 
   setNoDelay() {}
-  pause() {}
+  pause() {
+    this.pauseCalls += 1;
+  }
+  resume() {
+    this.resumeCalls += 1;
+  }
   write(data) {
     this.writes.push(data);
   }
@@ -145,6 +152,27 @@ function makeDeviceId(hexByte) {
   return Buffer.from(byte.repeat(20), 'hex');
 }
 
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+async function waitFor(predicate, timeoutMs = 1000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    if (predicate()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  assert.equal(predicate(), true);
+}
+
 test('PublishPort array input defaults host to 127.0.0.1', () => {
   const connection = new FakeConnection();
   const publishPort = new PublishPort(connection, [8080]);
@@ -211,6 +239,29 @@ test('TCP publish connects to configured host', () => {
   assert.deepEqual(connectCalls[0], { port: 8080, host: '192.168.1.10' });
 });
 
+test('TCP publish pauses local service socket while portSend is in flight', async () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, [8080]);
+  const localSocket = new FakeStreamSocket();
+  const send = deferred();
+  connection.RPC.portSend = async (...args) => {
+    connection.portSendCalls.push(args);
+    return send.promise;
+  };
+
+  publishPort.setupLocalSocketHandlers(localSocket, makeRef('04'), 'tcp', connection.RPC, connection);
+  localSocket.emit('data', Buffer.from('hello'));
+
+  await waitFor(() => connection.portSendCalls.length === 1);
+  assert.equal(localSocket.pauseCalls, 1);
+  assert.equal(localSocket.resumeCalls, 0);
+
+  send.resolve();
+  await waitFor(() => localSocket.resumeCalls === 1);
+
+  publishPort.stopListening();
+});
+
 test('TLS publish backend socket connects to configured host', () => {
   const connection = new FakeConnection();
   const publishPort = new PublishPort(connection, {

package/test/rpc.dioTraffic.test.js

@@ -0,0 +1,124 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('http');
+
+const DiodeRPC = require('../rpc');
+
+function withServer(handler) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(handler);
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      resolve({
+        port: server.address().port,
+        close: () => new Promise((done) => server.close(done)),
+      });
+    });
+  });
+}
+
+async function readJson(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+
+function makeRpc(port) {
+  return new DiodeRPC({ host: '127.0.0.1' }).dioTraffic({
+    protocol: 'http',
+    rpcPort: port,
+    chainId: 1284,
+    epoch: 687,
+  });
+}
+
+test('dioTraffic posts dio_traffic to the connected relay node RPC endpoint', async () => {
+  let requestBody = null;
+  const result = {
+    chain_id: '0x504',
+    epoch: '0x2af',
+    fleets: {},
+  };
+  const server = await withServer(async (req, res) => {
+    requestBody = await readJson(req);
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({
+      jsonrpc: '2.0',
+      id: requestBody.id,
+      result,
+    }));
+  });
+
+  try {
+    const response = await makeRpc(server.port);
+
+    assert.deepEqual(response, result);
+    assert.equal(requestBody.method, 'dio_traffic');
+    assert.deepEqual(requestBody.params, [1284, 687]);
+  } finally {
+    await server.close();
+  }
+});
+
+test('dioTraffic defaults to chain 1284 and omits epoch when not supplied', async () => {
+  let requestBody = null;
+  const server = await withServer(async (req, res) => {
+    requestBody = await readJson(req);
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ jsonrpc: '2.0', id: requestBody.id, result: { fleets: {} } }));
+  });
+
+  try {
+    const rpc = new DiodeRPC({ host: '127.0.0.1' });
+
+    await rpc.dioTraffic({
+      protocol: 'http',
+      rpcPort: server.port,
+    });
+
+    assert.deepEqual(requestBody.params, [1284]);
+  } finally {
+    await server.close();
+  }
+});
+
+test('dio_traffic aliases dioTraffic', async () => {
+  let requestBody = null;
+  const server = await withServer(async (req, res) => {
+    requestBody = await readJson(req);
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ jsonrpc: '2.0', id: requestBody.id, result: { fleets: {} } }));
+  });
+
+  try {
+    const rpc = new DiodeRPC({ host: '127.0.0.1' });
+
+    await rpc.dio_traffic({
+      protocol: 'http',
+      rpcPort: server.port,
+      chainId: 1284,
+    });
+
+    assert.deepEqual(requestBody.params, [1284]);
+  } finally {
+    await server.close();
+  }
+});
+
+test('dioTraffic throws JSON-RPC errors', async () => {
+  const server = await withServer(async (_req, res) => {
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ jsonrpc: '2.0', id: 1, error: { message: 'bad params' } }));
+  });
+
+  try {
+    await assert.rejects(
+      () => makeRpc(server.port),
+      /bad params/,
+    );
+  } finally {
+    await server.close();
+  }
+});