diodejs 0.0.3

package/README.md

@@ -0,0 +1,98 @@
+# diode_js
+
+## Overview
+`diode_js` is a JavaScript client for interacting with the Diode network. It provides functionalities to bind and publish ports, send RPC commands, and handle responses.
+
+## Installation
+```bash
+npm install diodejs
+```
+## Quick Start
+
+To get started, you need to generate a device certificate using OpenSSL. You can use this command:
+
+```bash
+openssl ecparam -name secp256k1 -out secp256k1_params.pem
+openssl req -newkey ec:./secp256k1_params.pem -nodes -keyout device_certificate.pem -x509 -days 365 -out device_certificate.pem -subj "/CN=device"
+```
+
+### Test RPC
+
+Here's a quick example to get you started with RPC functions using `DiodeRPC` Class
+
+```javascript
+const { DiodeConnection, DiodeRPC, makeReadable } = require('diodejs');
+
+async function main() {
+  const host = 'eu2.prenet.diode.io';
+  const port = 41046;
+  const certPath = 'device_certificate.pem';
+
+  const connection = new DiodeConnection(host, port, certPath);
+  await connection.connect();
+
+  const rpc = new DiodeRPC(connection);
+
+  try {
+    const ping = await rpc.ping();
+    console.log('Ping:', ping);
+    const blockPeak = await rpc.getBlockPeak();
+    console.log('Current Block Peak:', blockPeak);
+
+    const blockHeader = await rpc.getBlockHeader(blockPeak);
+    console.log('Block Header:', makeReadable(blockHeader));
+  } catch (error) {
+    console.error('RPC Error:', error);
+  } finally {
+    connection.close();
+  }
+}
+
+main();
+
+```
+
+### Bind Port
+Here's a quick example to get you started with port forwarding using the `BindPort` class.
+
+```javascript
+const { DiodeConnection, BindPort } = require('diodejs');
+
+async function main() {
+    const host = 'eu2.prenet.diode.io';
+    const port = 41046;
+    const certPath = 'device_certificate.pem';
+  
+    const connection = new DiodeConnection(host, port, certPath);
+    await connection.connect();
+  
+    const portForward = new BindPort(connection, 3002, 80, "5365baf29cb7ab58de588dfc448913cb609283e2");
+    portForward.bind();
+    
+}
+
+main();
+```
+### Publish Port
+
+Here's a quick example to get you started with publishing ports using the `PublishPort` class:
+
+```javascript
+const { DiodeConnection, PublishPort } = require('diodejs');
+
+async function main() {
+  const host = 'us2.prenet.diode.io';
+  const port = 41046;
+  const certPath = 'device_certificate.pem';
+
+  const connection = new DiodeConnection(host, port, certPath);
+  await connection.connect();
+
+  const publishedPorts = [8080]; // Ports you want to publish
+  const publishPort = new PublishPort(connection, publishedPorts, certPath);
+
+}
+
+main();
+
+```

package/bindPort.js

@@ -0,0 +1,120 @@
+const net = require('net');
+const { Buffer } = require('buffer');
+const DiodeRPC = require('./rpc');
+
+class BindPort {
+  constructor(connection, localPort, targetPort,deviceIdHex) {
+    this.connection = connection;
+    this.localPort = localPort;
+    this.targetPort = targetPort;
+    this.deviceIdHex = deviceIdHex;
+  }
+
+  bind () {
+    const deviceId = Buffer.from(this.deviceIdHex, 'hex');
+    const clientSockets = new Map();
+
+    const rpc = new DiodeRPC(this.connection);
+
+    // Listen for data events from the device
+    this.connection.on('unsolicited', (message) => {
+      // message is [messageId, [messageType, ...]]
+      const [messageIdRaw, messageContent] = message;
+      const messageTypeRaw = messageContent[0];
+      const messageType = Buffer.from(messageTypeRaw).toString('utf8');
+
+      if (messageType === 'data' || messageType === 'portsend') {
+        const refRaw = messageContent[1];
+        const dataRaw = messageContent[2];
+
+        const dataRef = Buffer.from(refRaw);
+        const data = Buffer.from(dataRaw);
+
+        // Find the associated client socket
+        const clientSocket = clientSockets.get(dataRef.toString('hex'));
+        if (clientSocket) {
+          clientSocket.write(data);
+        } else {
+          console.warn(`No client socket found for ref: ${dataRef.toString('hex')}`);
+        }
+      } else if (messageType === 'portclose') {
+        const refRaw = messageContent[1];
+
+        const dataRef = Buffer.from(refRaw);
+
+        // Close the associated client socket
+        const clientSocket = clientSockets.get(dataRef.toString('hex'));
+        if (clientSocket) {
+          clientSocket.end();
+          clientSockets.delete(dataRef.toString('hex'));
+          console.log(`Port closed for ref: ${dataRef.toString('hex')}`);
+        }
+      } else {
+        console.warn(`Unknown unsolicited message type: ${messageType}`);
+      }
+    });
+
+    // Set up local server
+    const server = net.createServer(async (clientSocket) => {
+      console.log('Client connected to local server');
+
+      // Open a new port on the device for this client
+      let ref;
+      try {
+        ref = await rpc.portOpen(deviceId, this.targetPort, 'rw');
+        console.log(`Port opened on device with ref: ${ref.toString('hex')} for client`);
+      } catch (error) {
+        console.error('Error opening port on device:', error);
+        clientSocket.destroy();
+        return;
+      }
+
+      // Store the client socket with the ref (using hex string as key)
+      clientSockets.set(ref.toString('hex'), clientSocket);
+
+      // When data is received from the client, send it to the device
+      clientSocket.on('data', async (data) => {
+        try {
+          await rpc.portSend(ref, data);
+        } catch (error) {
+          console.error('Error sending data to device:', error);
+          clientSocket.destroy();
+        }
+      });
+
+      // Handle client socket closure
+      clientSocket.on('end', async () => {
+        console.log('Client disconnected');
+        clientSockets.delete(ref.toString('hex'));
+        try {
+          console.log(`Port closed on device for ref: ${ref.toString('hex')}`);
+        } catch (error) {
+          console.error('Error closing port on device:', error);
+        }
+      });
+
+      // Handle client socket errors
+      clientSocket.on('error', (err) => {
+        console.error('Client socket error:', err);
+      });
+    });
+
+    server.listen(this.localPort, () => {
+      console.log(`Local server listening on port ${this.localPort}`);
+    });
+
+    // Handle device disconnect
+    this.connection.on('end', () => {
+      console.log('Disconnected from Diode.io server');
+      server.close();
+    });
+
+    // Handle connection errors
+    this.connection.on('error', (err) => {
+      console.error('Connection error:', err);
+      server.close();
+    });
+  }
+}
+
+module.exports = BindPort;