diodejs 0.4.0 → 0.4.2

package/test/fixtures/dio-network-snapshot.json

@@ -0,0 +1,82 @@
+[
+  {
+    "last_seen": "0x69aac815",
+    "retries": "0x00",
+    "last_error": "0x00",
+    "node_id": "0x7e4cd38d266902444dc9c8f7c0aa716a32497d0b",
+    "node": [
+      "server",
+      "144.126.157.138",
+      "0xa056",
+      "0xc76f",
+      "1.9.3",
+      [["name", "pause_chalk@diode-us2b"]]
+    ],
+    "connected": true
+  },
+  {
+    "last_seen": "0x69aac815",
+    "retries": "0x00",
+    "last_error": null,
+    "node_id": "0x3edd3d61a0f9b85a3adac02dfb97c7d48eaf5462",
+    "node": [
+      "server",
+      "192.168.100.4",
+      "0xa056",
+      "0xc76f",
+      "1.4.2",
+      [["name", "private_node"]]
+    ],
+    "connected": true
+  },
+  {
+    "last_seen": "0x69aac815",
+    "retries": "0x01",
+    "last_error": "0x69a69d52",
+    "node_id": "0x1350d3b501d6842ed881b59de4b95b27372bfae8",
+    "node": [
+      "server",
+      "194.233.80.251",
+      "0xa056",
+      "0xc76f",
+      "1.9.3",
+      [["name", "fringe_quiz@diode-as2b"]]
+    ],
+    "connected": true
+  },
+  {
+    "last_seen": "0x69aac815",
+    "retries": "0x00",
+    "last_error": "0x00",
+    "node_id": "0x1111111111111111111111111111111111111111",
+    "node": [
+      "client",
+      "1.2.3.4",
+      "0xa056",
+      "0xc76f",
+      "1.9.3",
+      [["name", "wrong_type"]]
+    ],
+    "connected": true
+  },
+  {
+    "last_seen": "0x69aac815",
+    "retries": "0x00",
+    "last_error": "0x00",
+    "node_id": "0x2222222222222222222222222222222222222222",
+    "node": [
+      "server",
+      "34.129.36.236",
+      "0xa056",
+      "0xc76f",
+      "1.9.3",
+      [["name", "public-alt"]]
+    ],
+    "connected": false
+  },
+  {
+    "node_id": "0x3333333333333333333333333333333333333333",
+    "node": ["server", "", "0xa056", "0xc76f", "1.9.3", []],
+    "connected": true
+  }
+]

package/test/fleetContract.test.js

@@ -0,0 +1,71 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const DiodeConnection = require('../connection');
+const { DEFAULT_FLEET_CONTRACT } = require('../utils');
+
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'diode-fleet-test-'));
+}
+
+function makeConnection() {
+  const tempDir = makeTempDir();
+  const keyLocation = path.join(tempDir, 'keys.json');
+  const connection = new DiodeConnection('relay.example', 41046, keyLocation);
+  connection.RPC = {
+    getEpoch: async () => 77,
+  };
+  connection._waitForServerEthereumAddress = async () => Buffer.from('aa'.repeat(20), 'hex');
+  return connection;
+}
+
+test('createTicketCommand uses the configured fleet contract in ticketv2', async () => {
+  const connection = makeConnection();
+
+  connection.setFleetContract('0x1111111111111111111111111111111111111111');
+  const command = await connection.createTicketCommand();
+
+  assert.equal(command[0], 'ticketv2');
+  assert.equal(command[2], 77);
+  assert.ok(Buffer.isBuffer(command[3]));
+  assert.equal(command[3].toString('hex'), '1111111111111111111111111111111111111111');
+});
+
+test('createTicketSignature changes when the fleet contract changes', async () => {
+  const connection = makeConnection();
+  const serverIdBuffer = Buffer.from('bb'.repeat(20), 'hex');
+  const totalConnections = 5;
+  const totalBytes = 123456;
+  const localAddress = 'client-a';
+  const epoch = 88;
+
+  const defaultSignature = await connection.createTicketSignature(
+    serverIdBuffer,
+    totalConnections,
+    totalBytes,
+    localAddress,
+    epoch,
+  );
+
+  connection.setFleetContract('0x2222222222222222222222222222222222222222');
+  const updatedSignature = await connection.createTicketSignature(
+    serverIdBuffer,
+    totalConnections,
+    totalBytes,
+    localAddress,
+    epoch,
+  );
+
+  assert.notDeepEqual(updatedSignature, defaultSignature);
+});
+
+test('DiodeConnection defaults to the existing fleet contract', async () => {
+  const connection = makeConnection();
+
+  const command = await connection.createTicketCommand();
+
+  assert.equal(command[3].toString('hex'), DEFAULT_FLEET_CONTRACT.slice(2));
+});

package/test/publishPort.test.js

@@ -0,0 +1,399 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const EventEmitter = require('events');
+const net = require('net');
+const tls = require('tls');
+const dgram = require('dgram');
+
+const PublishPort = require('../publishPort');
+
+class FakeStreamSocket extends EventEmitter {
+  constructor() {
+    super();
+    this.destroyed = false;
+    this.remoteAddress = undefined;
+    this.remotePort = undefined;
+  }
+
+  setNoDelay() {}
+  pause() {}
+  write() {}
+  end() {}
+  destroy() {
+    this.destroyed = true;
+  }
+  pipe(destination) {
+    return destination;
+  }
+}
+
+class FakeDatagramSocket extends EventEmitter {
+  constructor() {
+    super();
+    this.connectCalls = [];
+    this.sendCalls = [];
+    this.closed = false;
+    this.remoteAddress = undefined;
+    this.remotePort = undefined;
+  }
+
+  connect(port, host, callback) {
+    this.connectCalls.push({ port, host });
+    if (typeof callback === 'function') {
+      callback();
+    }
+  }
+
+  send(...args) {
+    if (args.length >= 3 && typeof args[1] === 'number' && typeof args[2] === 'string') {
+      this.sendCalls.push({ data: args[0], port: args[1], address: args[2] });
+    } else {
+      this.sendCalls.push({ data: args[0] });
+    }
+    const callback = args.find((arg) => typeof arg === 'function');
+    if (callback) {
+      callback(null);
+    }
+  }
+
+  close() {
+    this.closed = true;
+  }
+
+  setRecvBufferSize() {}
+  setSendBufferSize() {}
+}
+
+class FakeTlsSocket extends EventEmitter {
+  setNoDelay() {}
+  pipe(destination) {
+    return destination;
+  }
+}
+
+class FakeConnection extends EventEmitter {
+  constructor() {
+    super();
+    this.connections = new Map();
+    this.sentResponses = [];
+    this.sentErrors = [];
+    this.portCloseCalls = [];
+    this.portSendCalls = [];
+    this.RPC = {
+      sendResponse: async (...args) => {
+        this.sentResponses.push(args);
+      },
+      sendError: async (...args) => {
+        this.sentErrors.push(args);
+      },
+      portClose: async (...args) => {
+        this.portCloseCalls.push(args);
+      },
+      portSend: async (...args) => {
+        this.portSendCalls.push(args);
+      },
+    };
+  }
+
+  addConnection(ref, connectionInfo) {
+    this.connections.set(ref.toString('hex'), connectionInfo);
+  }
+
+  getConnection(ref) {
+    return this.connections.get(ref.toString('hex'));
+  }
+
+  deleteConnection(ref) {
+    return this.connections.delete(ref.toString('hex'));
+  }
+
+  getClientSocket() {
+    return null;
+  }
+
+  getServerRelayHost() {
+    return 'relay.example';
+  }
+
+  getDeviceCertificate() {
+    return 'fake-cert';
+  }
+
+  getEthereumAddress() {
+    return '0x' + 'aa'.repeat(20);
+  }
+
+  getPrivateKey() {
+    return Buffer.alloc(32, 1);
+  }
+}
+
+function makeRef(value = '01') {
+  return Buffer.from(value.padStart(2, '0'), 'hex');
+}
+
+function makeSessionId(value = '02') {
+  return Buffer.from(value.padStart(2, '0'), 'hex');
+}
+
+function makeDeviceId(hexByte) {
+  const byte = hexByte.length === 1 ? hexByte.repeat(2) : hexByte;
+  return Buffer.from(byte.repeat(20), 'hex');
+}
+
+test('PublishPort array input defaults host to 127.0.0.1', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, [8080]);
+
+  assert.deepEqual(publishPort.getPublishedPorts(), {
+    8080: { mode: 'public', whitelist: [], host: '127.0.0.1' },
+  });
+
+  publishPort.stopListening();
+});
+
+test('PublishPort preserves explicit host in object config', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    8080: { mode: 'private', whitelist: ['0xabc'], host: ' backend.internal ' },
+  });
+
+  assert.deepEqual(publishPort.getPublishedPorts(), {
+    8080: { mode: 'private', whitelist: ['0xabc'], host: 'backend.internal' },
+  });
+
+  publishPort.stopListening();
+});
+
+test('PublishPort rejects invalid host values', () => {
+  const connection = new FakeConnection();
+
+  assert.throws(() => {
+    new PublishPort(connection, { 8080: { mode: 'public', host: '   ' } });
+  }, TypeError);
+
+  assert.throws(() => {
+    new PublishPort(connection, { 8080: { mode: 'public', host: 42 } });
+  }, TypeError);
+});
+
+test('TCP publish connects to configured host', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    8080: { mode: 'public', host: '192.168.1.10' },
+  });
+  const originalConnect = net.connect;
+  const connectCalls = [];
+
+  net.connect = (options, callback) => {
+    const socket = new FakeStreamSocket();
+    connectCalls.push(options);
+    process.nextTick(() => {
+      if (typeof callback === 'function') {
+        callback();
+      }
+    });
+    return socket;
+  };
+
+  try {
+    publishPort.handleTCPConnection(makeSessionId(), makeRef(), 8080, '0x' + '11'.repeat(20), publishPort.getPublishedPorts()[8080], connection);
+  } finally {
+    net.connect = originalConnect;
+    publishPort.stopListening();
+  }
+
+  assert.equal(connectCalls.length, 1);
+  assert.deepEqual(connectCalls[0], { port: 8080, host: '192.168.1.10' });
+});
+
+test('TLS publish backend socket connects to configured host', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    8443: { mode: 'public', host: 'backend.internal' },
+  });
+  const originalConnect = net.connect;
+  const originalTlsSocket = tls.TLSSocket;
+  const connectCalls = [];
+
+  net.connect = (options, callback) => {
+    const socket = new FakeStreamSocket();
+    connectCalls.push(options);
+    process.nextTick(() => {
+      if (typeof callback === 'function') {
+        callback();
+      }
+    });
+    return socket;
+  };
+  tls.TLSSocket = FakeTlsSocket;
+
+  try {
+    publishPort.handleTLSConnection(makeSessionId(), makeRef('03'), 8443, '0x' + '11'.repeat(20), publishPort.getPublishedPorts()[8443], connection);
+  } finally {
+    net.connect = originalConnect;
+    tls.TLSSocket = originalTlsSocket;
+    publishPort.stopListening();
+  }
+
+  assert.equal(connectCalls.length, 1);
+  assert.deepEqual(connectCalls[0], { port: 8443, host: 'backend.internal' });
+});
+
+test('UDP publish stores and sends to configured host', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    5353: { mode: 'public', host: '192.168.1.20' },
+  });
+  const originalCreateSocket = dgram.createSocket;
+  const sockets = [];
+
+  dgram.createSocket = () => {
+    const socket = new FakeDatagramSocket();
+    sockets.push(socket);
+    return socket;
+  };
+
+  try {
+    const ref = makeRef('04');
+    publishPort.handleUDPConnection(makeSessionId('05'), ref, 5353, '0x' + '11'.repeat(20), publishPort.getPublishedPorts()[5353], connection);
+    publishPort.handlePortSend(makeSessionId('06'), ['portsend', ref, Buffer.from('hello')], connection);
+
+    const connectionInfo = connection.getConnection(ref);
+    assert.deepEqual(connectionInfo.remoteInfo, { port: 5353, address: '192.168.1.20' });
+    assert.equal(sockets[0].sendCalls.length, 1);
+    assert.equal(sockets[0].sendCalls[0].address, '192.168.1.20');
+    assert.equal(sockets[0].sendCalls[0].port, 5353);
+  } finally {
+    dgram.createSocket = originalCreateSocket;
+    publishPort.stopListening();
+  }
+});
+
+test('native TCP publish connects local socket to configured host', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    8089: { mode: 'public', host: '10.0.0.8' },
+  });
+  const originalConnect = net.connect;
+  const connectCalls = [];
+
+  net.connect = (options, callback) => {
+    const socket = new FakeStreamSocket();
+    connectCalls.push(options);
+    process.nextTick(() => {
+      if (typeof callback === 'function') {
+        callback();
+      }
+      socket.emit('connect');
+    });
+    return socket;
+  };
+
+  try {
+    publishPort.handleNativeTCPRelay(
+      makeSessionId('07'),
+      41000,
+      { physicalPort: 41000, port: 8089, host: '10.0.0.8', deviceId: '0x' + '11'.repeat(20), ready: false, session: null },
+      connection
+    );
+  } finally {
+    net.connect = originalConnect;
+    publishPort.stopListening();
+  }
+
+  assert.equal(connectCalls.length, 2);
+  assert.deepEqual(connectCalls[0], { host: 'relay.example', port: 41000 });
+  assert.deepEqual(connectCalls[1], { port: 8089, host: '10.0.0.8' });
+});
+
+test('native UDP publish connects local socket to configured host', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    8090: { mode: 'public', host: 'backend.internal' },
+  });
+  const originalCreateSocket = dgram.createSocket;
+  const sockets = [];
+
+  dgram.createSocket = () => {
+    const socket = new FakeDatagramSocket();
+    sockets.push(socket);
+    return socket;
+  };
+
+  try {
+    publishPort.handleNativeUDPRelay(
+      makeSessionId('08'),
+      41001,
+      { physicalPort: 41001, port: 8090, host: 'backend.internal', deviceId: '0x' + '11'.repeat(20), ready: false, session: null },
+      connection
+    );
+  } finally {
+    dgram.createSocket = originalCreateSocket;
+    publishPort.stopListening();
+  }
+
+  assert.equal(sockets.length, 2);
+  assert.deepEqual(sockets[0].connectCalls[0], { port: 41001, host: 'relay.example' });
+  assert.deepEqual(sockets[1].connectCalls[0], { port: 8090, host: 'backend.internal' });
+});
+
+test('handlePortOpen preserves localhost default when host is omitted', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, [8081]);
+  const originalConnect = net.connect;
+  const connectCalls = [];
+
+  net.connect = (options, callback) => {
+    const socket = new FakeStreamSocket();
+    connectCalls.push(options);
+    process.nextTick(() => {
+      if (typeof callback === 'function') {
+        callback();
+      }
+    });
+    return socket;
+  };
+
+  try {
+    publishPort.handlePortOpen(
+      makeSessionId('09'),
+      ['portopen', '8081', makeRef('0a'), makeDeviceId('1')],
+      connection
+    );
+  } finally {
+    net.connect = originalConnect;
+    publishPort.stopListening();
+  }
+
+  assert.deepEqual(connectCalls[0], { port: 8081, host: '127.0.0.1' });
+});
+
+test('handlePortOpen rejects non-whitelisted devices before connecting', () => {
+  const connection = new FakeConnection();
+  const publishPort = new PublishPort(connection, {
+    3000: { mode: 'private', whitelist: ['0x' + '22'.repeat(20)], host: '192.168.1.30' },
+  });
+  const originalConnect = net.connect;
+  let connectCalled = false;
+
+  net.connect = () => {
+    connectCalled = true;
+    return new FakeStreamSocket();
+  };
+
+  try {
+    publishPort.handlePortOpen(
+      makeSessionId('0b'),
+      ['portopen', '3000', makeRef('0c'), makeDeviceId('1')],
+      connection
+    );
+  } finally {
+    net.connect = originalConnect;
+    publishPort.stopListening();
+  }
+
+  assert.equal(connectCalled, false);
+  assert.equal(connection.sentErrors.length, 1);
+  assert.equal(connection.sentErrors[0][2], 'Device not whitelisted');
+});

package/utils.js

@@ -199,6 +199,30 @@ function ensureDirectoryExistence(filePath) {
   fs.mkdirSync(dirname);
 }
 
+const DEFAULT_FLEET_CONTRACT = '0x6000000000000000000000000000000000000000';
+
+function normalizeFleetContractAddress(value) {
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    const buffer = toBufferView(value);
+    if (buffer.length !== 20) {
+      throw new Error('fleetContract must be a 20-byte EVM address');
+    }
+    return `0x${buffer.toString('hex')}`.toLowerCase();
+  }
+
+  if (typeof value !== 'string') {
+    throw new Error('fleetContract must be a 20-byte EVM address hex string');
+  }
+
+  const trimmed = value.trim();
+  const hex = trimmed.toLowerCase().startsWith('0x') ? trimmed.slice(2) : trimmed;
+  if (!/^[0-9a-fA-F]{40}$/.test(hex)) {
+    throw new Error('fleetContract must be a 20-byte EVM address hex string');
+  }
+
+  return `0x${hex.toLowerCase()}`;
+}
+
 module.exports = { 
   makeReadable, 
   parseRequestId, 
@@ -209,4 +233,6 @@ module.exports = {
   loadOrGenerateKeyPair,
   ensureDirectoryExistence,
   toBufferView,
+  DEFAULT_FLEET_CONTRACT,
+  normalizeFleetContractAddress,
 };