diodejs 0.2.2 → 0.4.0

package/examples/nativeForwardTest.js

@@ -0,0 +1,80 @@
+const net = require('net');
+const dgram = require('dgram');
+const { KEYUTIL } = require('jsrsasign');
+const { DiodeClientManager, PublishPort } = 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);
+  }
+}
+
+function startTcpEcho(port) {
+  const server = net.createServer((socket) => {
+    socket.setNoDelay(true);
+    socket.on('data', (data) => {
+      socket.write(data);
+    });
+  });
+
+  server.listen(port, () => {
+    console.log(`TCP echo listening on ${port}`);
+  });
+
+  return server;
+}
+
+function startUdpEcho(port) {
+  const socket = dgram.createSocket('udp4');
+  socket.on('message', (msg, rinfo) => {
+    socket.send(msg, rinfo.port, rinfo.address);
+  });
+  socket.bind(port, () => {
+    console.log(`UDP echo listening on ${port}`);
+  });
+  return socket;
+}
+
+async function main() {
+  const keyLocation = './db/keys.json';
+
+  const tcpServer = startTcpEcho(8089);
+  const udpSocket = startUdpEcho(8090);
+
+  const client = new DiodeClientManager({keyLocation });
+  await client.connect();
+  const [connection] = client.getConnections();
+  if (!connection) {
+    throw new Error('No relay connection available');
+  }
+
+  printPublicKey(connection);
+
+  const publishPort = new PublishPort(client, {
+    8089: { mode: 'public' },
+    8090: { mode: 'public' }
+  });
+
+  console.log('Native forward ports published:', publishPort.getPublishedPorts());
+
+  const shutdown = () => {
+    try { client.close(); } catch {}
+    try { tcpServer.close(); } catch {}
+    try { udpSocket.close(); } catch {}
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch(console.error);

package/examples/nativeTcpClientTest.js

@@ -0,0 +1,56 @@
+const net = require('net');
+
+const host = process.argv[2] || '127.0.0.1';
+const port = Number(process.argv[3] || 3005);
+const message = process.argv.slice(4).join(' ') || 'hello-tcp';
+const intervalMs = Number(process.env.INTERVAL_MS || 1000);
+const connectTimeoutMs = Number(process.env.CONNECT_TIMEOUT_MS || 5000);
+
+let intervalId = null;
+let connected = false;
+let counter = 0;
+
+const client = net.createConnection({ host, port }, () => {
+  connected = true;
+  client.setNoDelay(true);
+  clearTimeout(connectTimer);
+  const sendPayload = () => {
+    const payload = `${message} #${counter++} ${new Date().toISOString()}`;
+    client.write(Buffer.from(payload, 'utf8'));
+  };
+  sendPayload();
+  intervalId = setInterval(sendPayload, intervalMs);
+});
+
+const connectTimer = setTimeout(() => {
+  if (connected) return;
+  console.error(`Connect timeout after ${connectTimeoutMs}ms`);
+  client.destroy();
+  process.exitCode = 1;
+}, connectTimeoutMs);
+
+client.on('data', (data) => {
+  console.log(data.toString('utf8'));
+});
+
+client.on('end', () => {
+  if (intervalId) clearInterval(intervalId);
+});
+
+client.on('close', () => {
+  if (intervalId) clearInterval(intervalId);
+});
+
+client.on('error', (err) => {
+  if (intervalId) clearInterval(intervalId);
+  console.error(`TCP error: ${err.message}`);
+  process.exitCode = 1;
+});
+
+const shutdown = () => {
+  if (intervalId) clearInterval(intervalId);
+  if (!client.destroyed) client.end();
+};
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/examples/nativeUdpClientTest.js

@@ -0,0 +1,40 @@
+const dgram = require('dgram');
+
+const host = process.argv[2] || '127.0.0.1';
+const port = Number(process.argv[3] || 3006);
+const message = process.argv.slice(4).join(' ') || 'hello-udp';
+const intervalMs = Number(process.env.INTERVAL_MS || 1000);
+
+const socket = dgram.createSocket('udp4');
+let intervalId = null;
+let counter = 0;
+
+const sendPayload = () => {
+  const payload = Buffer.from(`${message} #${counter++} ${new Date().toISOString()}`, 'utf8');
+  socket.send(payload, port, host);
+};
+
+socket.on('message', (msg) => {
+  if (msg.length === 0 || (msg.length === 1 && msg[0] === 0)) {
+    return;
+  }
+  console.log(msg.toString('utf8'));
+});
+
+socket.on('error', (err) => {
+  if (intervalId) clearInterval(intervalId);
+  console.error(`UDP error: ${err.message}`);
+  socket.close();
+  process.exitCode = 1;
+});
+
+sendPayload();
+intervalId = setInterval(sendPayload, intervalMs);
+
+const shutdown = () => {
+  if (intervalId) clearInterval(intervalId);
+  socket.close();
+};
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/examples/portForwardTest.js

@@ -1,14 +1,12 @@
-const { DiodeConnection, BindPort } = require('../index');
+const { DiodeClientManager, BindPort } = require('../index');
 
 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 client = new DiodeClientManager({ keyLocation });
+    await client.connect();
   
-    const portForward = new BindPort(connection, {
+    const portForward = new BindPort(client, {
         3003: { targetPort: 8080, deviceIdHex: "0xca1e71d8105a598810578fb6042fa8cbc1e7f039", protocol: "tcp" },
         3004: { targetPort: 8081, deviceIdHex: "5365baf29cb7ab58de588dfc448913cb609283e2", protocol: "tls" }
       });
@@ -29,4 +27,4 @@ async function main() {
     
 }
 
-main().catch(console.error);
+main().catch(console.error);

package/examples/publishAndBind.js

@@ -1,23 +1,19 @@
-const DiodeConnection = require('../connection')
-const PublishPort = require('../publishPort')
-const BindPort = require('../bindPort')
+const { DiodeClientManager, PublishPort, BindPort } = require('../index')
 
-const host = 'us2.prenet.diode.io';
-const port = 41046;
 const keyLocation = './db/keys.json';
 
-const connection = new DiodeConnection(host, port, keyLocation);
+const client = new DiodeClientManager({ keyLocation });
 
 async function main() {
-    await connection.connect();
+    await client.connect();
     const publishedPorts = [8080]; // Ports you want to publish
-    const publishPort = new PublishPort(connection, publishedPorts);
+    const publishPort = new PublishPort(client, publishedPorts);
 
-    const portForward = new BindPort(connection, 3002, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    const portForward = new BindPort(client, 3002, 8080, "5365baf29cb7ab58de588dfc448913cb609283e2");
     portForward.bind();
 
 }
 
 main();
 
-    
+    

package/examples/publishPortTest.js

@@ -1,17 +1,15 @@
 // example.js
 
-const { DiodeConnection, PublishPort } = require('../index');
+const { DiodeClientManager, PublishPort } = require('../index');
 
 async function startPublishing() {
-  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 client = new DiodeClientManager({ keyLocation });
+  await client.connect();
 
   // Create a PublishPort instance with initial ports
-  const publishPort = new PublishPort(connection, {
+  const publishPort = new PublishPort(client, {
     3000: { mode: 'public' },
     8080: { 
       mode: 'private',

package/index.js

@@ -1,8 +1,15 @@
 // index.js
 const DiodeConnection = require('./connection');
+const DiodeClientManager = require('./clientManager');
 const DiodeRPC = require('./rpc');
 const BindPort = require('./bindPort');
 const PublishPort = require('./publishPort');
 const makeReadable = require('./utils').makeReadable;
 const logger = require('./logger');
-module.exports = { DiodeConnection, DiodeRPC, BindPort , PublishPort, makeReadable, logger };
+process.on('unhandledRejection', (reason) => {
+  try { logger.warn(() => `Unhandled promise rejection: ${reason}`); } catch {}
+});
+process.on('uncaughtException', (err) => {
+  try { logger.error(() => `Uncaught exception: ${err.stack || err.message}`); } catch {}
+});
+module.exports = { DiodeConnection, DiodeClientManager, DiodeRPC, BindPort , PublishPort, makeReadable, logger };

package/logger.js

@@ -19,10 +19,15 @@ const options = {
 
 const logger = setupLogger(options);
 
+// Evaluate function args lazily to avoid building strings if logs are disabled
+const evalArg = (a) => (typeof a === 'function' ? a() : a);
+const mapArgs = (args) => args.map(evalArg);
+const shouldDebug = isDebug && isLogEnabled;
+
 // Wrap logger calls to respect debug mode
 module.exports = {
-  debug: (...args) => { if (isDebug && isLogEnabled) logger.debug(...args, 'app'); },
-  info: (...args) => { if (isLogEnabled) logger.info(...args, 'app'); },
-  warn: (...args) => { if (isLogEnabled) logger.warn(...args, 'app'); },
-  error: (...args) => { if (isLogEnabled) logger.error(...args, 'app'); },
-};
+  debug: (...args) => { if (shouldDebug) logger.debug(...mapArgs(args), 'app'); },
+  info: (...args) => { if (isLogEnabled) logger.info(...mapArgs(args), 'app'); },
+  warn: (...args) => { if (isLogEnabled) logger.warn(...mapArgs(args), 'app'); },
+  error: (...args) => { if (isLogEnabled) logger.error(...mapArgs(args), 'app'); },
+};

package/nativeCrypto.js

@@ -0,0 +1,321 @@
+const crypto = require('crypto');
+const secp256k1 = require('secp256k1');
+const ethUtil = require('ethereumjs-util');
+
+const DOMAIN = Buffer.from('diode-pp2-v1', 'utf8');
+const UDP_MAGIC = Buffer.from('DUD1', 'utf8');
+
+function toDeviceIdBuffer(deviceId) {
+  if (!deviceId) return Buffer.alloc(0);
+  if (Buffer.isBuffer(deviceId)) return deviceId;
+  if (deviceId instanceof Uint8Array) return Buffer.from(deviceId);
+  if (typeof deviceId === 'string') {
+    const hex = deviceId.toLowerCase().startsWith('0x') ? deviceId.slice(2) : deviceId;
+    return Buffer.from(hex, 'hex');
+  }
+  return Buffer.alloc(0);
+}
+
+function encodeHandshakeData(role, deviceId, ephPub, nonce, physicalPort) {
+  const deviceIdBuf = toDeviceIdBuffer(deviceId);
+  const portBuf = Buffer.alloc(4);
+  portBuf.writeUInt32BE(physicalPort >>> 0, 0);
+  return Buffer.concat([
+    DOMAIN,
+    Buffer.from(role, 'utf8'),
+    deviceIdBuf,
+    ephPub,
+    nonce,
+    portBuf,
+  ]);
+}
+
+function signHandshake(privateKey, data) {
+  const hash = ethUtil.keccak256(data);
+  const sig = ethUtil.ecsign(hash, privateKey);
+  return Buffer.concat([sig.r, sig.s, Buffer.from([sig.v])]);
+}
+
+function verifyHandshakeSignature(data, signature, expectedDeviceId) {
+  if (!signature || signature.length !== 65) {
+    return { ok: false, reason: 'Invalid signature length' };
+  }
+  const hash = ethUtil.keccak256(data);
+  const r = signature.slice(0, 32);
+  const s = signature.slice(32, 64);
+  let v = signature[64];
+  if (v < 27) v += 27;
+  let pubKey;
+  try {
+    pubKey = ethUtil.ecrecover(hash, v, r, s);
+  } catch (error) {
+    return { ok: false, reason: 'Invalid signature' };
+  }
+  const addr = `0x${ethUtil.pubToAddress(pubKey).toString('hex')}`.toLowerCase();
+  if (expectedDeviceId && addr !== expectedDeviceId.toLowerCase()) {
+    return { ok: false, reason: 'Device mismatch', address: addr };
+  }
+  return { ok: true, address: addr };
+}
+
+function generateEphemeralKeyPair() {
+  let privKey;
+  do {
+    privKey = crypto.randomBytes(32);
+  } while (!secp256k1.privateKeyVerify(privKey));
+  const pubKey = Buffer.from(secp256k1.publicKeyCreate(privKey, true)); // compressed 33 bytes
+  return { privKey, pubKey };
+}
+
+function createHandshakeMessage({ role, deviceId, physicalPort, privateKey }) {
+  const { privKey, pubKey } = generateEphemeralKeyPair();
+  const nonce = crypto.randomBytes(16);
+  const data = encodeHandshakeData(role, deviceId, pubKey, nonce, physicalPort);
+  const sig = signHandshake(privateKey, data);
+  const message = {
+    v: 1,
+    role,
+    deviceId: deviceId.toLowerCase(),
+    physicalPort,
+    ephPub: pubKey.toString('hex'),
+    nonce: nonce.toString('hex'),
+    sig: sig.toString('hex'),
+  };
+  return { message, privKey, nonce };
+}
+
+function verifyHandshakeMessage(message, { expectedRole, expectedDeviceId, expectedPhysicalPort }) {
+  if (!message || message.v !== 1) {
+    return { ok: false, reason: 'Invalid version' };
+  }
+  if (expectedRole && message.role !== expectedRole) {
+    return { ok: false, reason: 'Role mismatch' };
+  }
+  if (expectedPhysicalPort && Number(message.physicalPort) !== Number(expectedPhysicalPort)) {
+    return { ok: false, reason: 'Physical port mismatch' };
+  }
+  if (expectedDeviceId && message.deviceId && message.deviceId.toLowerCase() !== expectedDeviceId.toLowerCase()) {
+    return { ok: false, reason: 'Device mismatch' };
+  }
+
+  const ephPub = Buffer.from(message.ephPub, 'hex');
+  const nonce = Buffer.from(message.nonce, 'hex');
+  const sig = Buffer.from(message.sig, 'hex');
+  const data = encodeHandshakeData(message.role, message.deviceId, ephPub, nonce, message.physicalPort);
+  const verification = verifyHandshakeSignature(data, sig, message.deviceId);
+  if (!verification.ok) {
+    return { ok: false, reason: verification.reason };
+  }
+  return { ok: true, deviceId: message.deviceId, ephPub, nonce };
+}
+
+function deriveSessionKeys({
+  role,
+  localDeviceId,
+  remoteDeviceId,
+  localEphPriv,
+  remoteEphPub,
+  localNonce,
+  remoteNonce,
+  physicalPort,
+}) {
+  const shared = Buffer.from(secp256k1.ecdh(remoteEphPub, localEphPriv));
+  const bindFirst = role === 'bind';
+  const nonceBind = bindFirst ? localNonce : remoteNonce;
+  const noncePublish = bindFirst ? remoteNonce : localNonce;
+  const idBind = toDeviceIdBuffer(bindFirst ? localDeviceId : remoteDeviceId);
+  const idPublish = toDeviceIdBuffer(bindFirst ? remoteDeviceId : localDeviceId);
+  const portBuf = Buffer.alloc(4);
+  portBuf.writeUInt32BE(physicalPort >>> 0, 0);
+  const salt = crypto.createHash('sha256')
+    .update(Buffer.concat([nonceBind, noncePublish, idBind, idPublish, portBuf]))
+    .digest();
+  const info = Buffer.from('diode-pp2-v1', 'utf8');
+  const keyMaterial = Buffer.from(crypto.hkdfSync('sha256', shared, salt, info, 72));
+
+  let txKey = keyMaterial.slice(0, 32);
+  let rxKey = keyMaterial.slice(32, 64);
+  let txSalt = keyMaterial.slice(64, 68);
+  let rxSalt = keyMaterial.slice(68, 72);
+
+  if (role === 'publish') {
+    [txKey, rxKey] = [rxKey, txKey];
+    [txSalt, rxSalt] = [rxSalt, txSalt];
+  }
+
+  return {
+    txKey,
+    rxKey,
+    txSalt,
+    rxSalt,
+    txCounter: 0n,
+    rxCounter: 0n,
+    rxBuffer: Buffer.alloc(0),
+  };
+}
+
+function buildNonce(salt, counter) {
+  const nonce = Buffer.alloc(12);
+  salt.copy(nonce, 0, 0, 4);
+  nonce.writeBigUInt64BE(counter, 4);
+  return nonce;
+}
+
+function encryptAead(key, nonce, plaintext, aad) {
+  const cipher = crypto.createCipheriv('chacha20-poly1305', key, nonce, { authTagLength: 16 });
+  if (aad) cipher.setAAD(aad);
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return { ciphertext, tag };
+}
+
+function decryptAead(key, nonce, ciphertext, tag, aad) {
+  const decipher = crypto.createDecipheriv('chacha20-poly1305', key, nonce, { authTagLength: 16 });
+  if (aad) decipher.setAAD(aad);
+  decipher.setAuthTag(tag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return plaintext;
+}
+
+function createTcpFrame(session, plaintext) {
+  const counter = session.txCounter++;
+  const nonce = buildNonce(session.txSalt, counter);
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(plaintext.length, 0);
+  const counterBuf = Buffer.alloc(8);
+  counterBuf.writeBigUInt64BE(counter, 0);
+  const aad = Buffer.concat([lenBuf, counterBuf]);
+  const { ciphertext, tag } = encryptAead(session.txKey, nonce, plaintext, aad);
+  return Buffer.concat([lenBuf, counterBuf, ciphertext, tag]);
+}
+
+function consumeTcpFrames(session, data) {
+  const messages = [];
+  let buffer = Buffer.concat([session.rxBuffer, data]);
+  while (buffer.length >= 12) {
+    const len = buffer.readUInt32BE(0);
+    const counter = buffer.readBigUInt64BE(4);
+    const frameLength = 12 + len + 16;
+    if (buffer.length < frameLength) break;
+    if (counter < session.rxCounter) {
+      buffer = buffer.slice(frameLength);
+      continue;
+    }
+    const nonce = buildNonce(session.rxSalt, counter);
+    const aad = buffer.slice(0, 12);
+    const ciphertext = buffer.slice(12, 12 + len);
+    const tag = buffer.slice(12 + len, frameLength);
+    try {
+      const plaintext = decryptAead(session.rxKey, nonce, ciphertext, tag, aad);
+      messages.push(plaintext);
+      session.rxCounter = counter + 1n;
+    } catch (error) {
+      throw new Error('TCP decrypt failed');
+    }
+    buffer = buffer.slice(frameLength);
+  }
+  session.rxBuffer = buffer;
+  return messages;
+}
+
+function createUdpPacket(session, plaintext) {
+  const counter = session.txCounter++;
+  const nonce = buildNonce(session.txSalt, counter);
+  const counterBuf = Buffer.alloc(8);
+  counterBuf.writeBigUInt64BE(counter, 0);
+  const aad = Buffer.concat([UDP_MAGIC, counterBuf]);
+  const { ciphertext, tag } = encryptAead(session.txKey, nonce, plaintext, aad);
+  return Buffer.concat([UDP_MAGIC, counterBuf, ciphertext, tag]);
+}
+
+function parseUdpPacket(session, packet) {
+  if (packet.length < UDP_MAGIC.length + 8 + 16) {
+    return null;
+  }
+  if (!packet.slice(0, 4).equals(UDP_MAGIC)) {
+    return null;
+  }
+  const counter = packet.readBigUInt64BE(4);
+  if (counter < session.rxCounter) {
+    return null;
+  }
+  const nonce = buildNonce(session.rxSalt, counter);
+  const aad = packet.slice(0, 12);
+  const ciphertext = packet.slice(12, packet.length - 16);
+  const tag = packet.slice(packet.length - 16);
+  try {
+    const plaintext = decryptAead(session.rxKey, nonce, ciphertext, tag, aad);
+    session.rxCounter = counter + 1n;
+    return plaintext;
+  } catch (error) {
+    return null;
+  }
+}
+
+function writeHandshakeMessage(socket, message) {
+  const payload = Buffer.from(JSON.stringify(message), 'utf8');
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(payload.length, 0);
+  socket.write(Buffer.concat([lenBuf, payload]));
+}
+
+function readHandshakeMessage(socket, timeoutMs = 10000) {
+  return new Promise((resolve, reject) => {
+    let buffer = Buffer.alloc(0);
+    let settled = false;
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error('Handshake timeout'));
+    }, timeoutMs);
+
+    const cleanup = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.off('data', onData);
+      socket.off('error', onError);
+      socket.off('close', onClose);
+    };
+
+    const onError = (err) => {
+      cleanup();
+      reject(err);
+    };
+
+    const onClose = () => {
+      cleanup();
+      reject(new Error('Handshake socket closed'));
+    };
+
+    const onData = (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length < 4) return;
+      const len = buffer.readUInt32BE(0);
+      if (buffer.length < 4 + len) return;
+      const payload = buffer.slice(4, 4 + len);
+      cleanup();
+      try {
+        const message = JSON.parse(payload.toString('utf8'));
+        resolve(message);
+      } catch (error) {
+        reject(error);
+      }
+    };
+
+    socket.on('data', onData);
+    socket.on('error', onError);
+    socket.on('close', onClose);
+  });
+}
+
+module.exports = {
+  createHandshakeMessage,
+  verifyHandshakeMessage,
+  deriveSessionKeys,
+  writeHandshakeMessage,
+  readHandshakeMessage,
+  createTcpFrame,
+  consumeTcpFrames,
+  createUdpPacket,
+  parseUdpPacket,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diodejs",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "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": {
@@ -11,20 +11,18 @@
   "dependencies": {
     "@ethereumjs/rlp": "^5.0.2",
     "asn1.js": "^5.4.1",
-    "buffer": "^6.0.3",
-    "crypto": "^1.0.1",
     "dera-logger": "^2.0.0",
-    "dgram": "^1.0.1",
     "dotenv": "^16.4.7",
     "ethereumjs-abi": "^0.6.8",
     "ethereumjs-util": "^7.1.5",
     "ethers": "^6.13.2",
-    "fs": "^0.0.1-security",
     "jsrsasign": "^11.1.0",
-    "net": "^1.0.2",
+    "keccak": "^3.0.4",
     "node-fetch": "^2.7.0",
     "rlp": "^3.0.0",
-    "secp256k1": "^5.0.1",
-    "tls": "^0.0.1"
+    "secp256k1": "^5.0.1"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }