diodejs 0.0.3

package/publishPort.js

@@ -0,0 +1,295 @@
+// publishPort.js
+
+const net = require('net');
+const tls = require('tls');
+const dgram = require('dgram');
+const fs = require('fs');
+const { Buffer } = require('buffer');
+const EventEmitter = require('events');
+const { Duplex } = require('stream');
+const DiodeRPC = require('./rpc');
+
+class DiodeSocket extends Duplex {
+  constructor(ref, rpc) {
+    super();
+    this.ref = ref;
+    this.rpc = rpc;
+  }
+
+  _write(chunk, encoding, callback) {
+    // Send data to the Diode client via portSend
+    this.rpc.portSend(this.ref, chunk)
+      .then(() => callback())
+      .catch((err) => callback(err));
+  }
+
+  _read(size) {
+    // No need to implement this method
+  }
+
+  // Method to push data received from Diode client
+  pushData(data) {
+    this.push(data);
+  }
+}
+
+class PublishPort extends EventEmitter {
+  constructor(connection, publishedPorts, certPath) {
+    super();
+    this.connection = connection;
+    this.publishedPorts = publishedPorts; // Array of ports to publish
+    this.connections = new Map(); // Map to store active connections
+    this.startListening();
+    this.rpc = new DiodeRPC(connection);
+    this.certPath = certPath;
+  }
+
+  startListening() {
+    // Listen for unsolicited messages from the connection
+    this.connection.on('unsolicited', (message) => {
+      const [sessionIdRaw, messageContent] = message;
+      const messageTypeRaw = messageContent[0];
+      const messageType = Buffer.from(messageTypeRaw).toString('utf8');
+
+      if (messageType === 'portopen') {
+        this.handlePortOpen(sessionIdRaw, messageContent);
+      } else if (messageType === 'portsend') {
+        this.handlePortSend(sessionIdRaw, messageContent);
+      } else if (messageType === 'portclose') {
+        this.handlePortClose(sessionIdRaw, messageContent);
+      } else {
+        console.warn(`Unknown unsolicited message type: ${messageType}`);
+      }
+    });
+  }
+
+  handlePortOpen(sessionIdRaw, messageContent) {
+    // messageContent: ['portopen', portString, ref, deviceId]
+    const portStringRaw = messageContent[1];
+    const refRaw = messageContent[2];
+    const deviceIdRaw = messageContent[3];
+
+    const sessionId = Buffer.from(sessionIdRaw);
+    const portString = Buffer.from(portStringRaw).toString('utf8');
+    const ref = Buffer.from(refRaw);
+    const deviceId = Buffer.from(deviceIdRaw).toString('hex');
+
+    console.log(`Received portopen request for portString ${portString} with ref ${ref.toString('hex')} from device ${deviceId}`);
+
+    // Extract protocol and port number from portString
+    const [protocol, portStr] = portString.split(':');
+    const port = parseInt(portStr, 10);
+
+    // Check if the port is published
+    if (!this.publishedPorts.includes(port)) {
+      console.warn(`Port ${port} is not published. Rejecting request.`);
+      // Send error response
+      this.rpc.sendError(sessionId, ref, 'Port is not published');
+      return;
+    }
+
+    // Handle based on protocol
+    if (protocol === 'tcp') {
+      this.handleTCPConnection(sessionId, ref, port);
+    } else if (protocol === 'tls') {
+      this.handleTLSConnection(sessionId, ref, port);
+    } else if (protocol === 'udp') {
+      this.handleUDPConnection(sessionId, ref, port);
+    } else {
+      console.warn(`Unsupported protocol: ${protocol}`);
+      this.rpc.sendError(sessionId, ref, `Unsupported protocol: ${protocol}`);
+    }
+  }
+
+  setupLocalSocketHandlers(localSocket, ref, protocol) {
+    if (protocol === 'udp') {
+      
+    } else {
+      localSocket.on('data', (data) => {
+        // When data is received from the local service, send it back via Diode
+        this.rpc.portSend(ref, data);
+      });
+
+      localSocket.on('end', () => {
+        console.log(`Local service disconnected`);
+        // Send portclose message to Diode
+        this.rpc.portClose(ref);
+        this.connections.delete(ref.toString('hex'));
+      });
+
+      localSocket.on('error', (err) => {
+        console.error(`Error with local service:`, err);
+        // Send portclose message to Diode
+        this.rpc.portClose(ref);
+        this.connections.delete(ref.toString('hex'));
+      });
+    }
+  }
+
+  handleTCPConnection(sessionId, ref, port) {
+    // Create a TCP connection to the local service on the specified port
+    const localSocket = net.connect({ port: port }, () => {
+      console.log(`Connected to local TCP service on port ${port}`);
+      // Send success response
+      this.rpc.sendResponse(sessionId, ref, 'ok');
+    });
+
+    // Handle data, end, and error events
+    this.setupLocalSocketHandlers(localSocket, ref, 'tcp');
+
+    // Store the local socket with the ref
+    this.connections.set(ref.toString('hex'), { socket: localSocket, protocol: 'tcp' });
+  }
+
+  handleTLSConnection(sessionId, ref, port) {
+    // Create a DiodeSocket instance
+    const diodeSocket = new DiodeSocket(ref, this.rpc);
+
+    // TLS options with your server's certificate and key
+    const tlsOptions = {
+      cert: fs.readFileSync(this.certPath),
+      key: fs.readFileSync(this.certPath),
+      rejectUnauthorized: false,
+      ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384',
+      ecdhCurve: 'secp256k1',
+      minVersion: 'TLSv1.2',
+      maxVersion: 'TLSv1.2',
+    };
+
+    // Create a TLS socket in server mode using the DiodeSocket
+    const tlsSocket = new tls.TLSSocket(diodeSocket, {
+      isServer: true,
+      ...tlsOptions,
+    });
+
+    // Connect to the local service (TCP or TLS as needed)
+    const localSocket = net.connect({ port: port }, () => {
+      console.log(`Connected to local TCP service on port ${port}`);
+      // Send success response
+      this.rpc.sendResponse(sessionId, ref, 'ok');
+    });
+
+    // Pipe data between the TLS socket and the local service
+    tlsSocket.pipe(localSocket).pipe(tlsSocket);
+
+    // Handle errors and cleanup
+    tlsSocket.on('error', (err) => {
+      console.error('TLS Socket error:', err);
+      this.rpc.portClose(ref);
+      this.connections.delete(ref.toString('hex'));
+    });
+
+    tlsSocket.on('close', () => {
+      console.log('TLS Socket closed');
+      this.connections.delete(ref.toString('hex'));
+    });
+
+    // Store the connection info
+    this.connections.set(ref.toString('hex'), {
+      diodeSocket,
+      tlsSocket,
+      localSocket,
+      protocol: 'tls',
+    });
+  }
+
+  handleUDPConnection(sessionId, ref, port) {
+    // Create a UDP socket
+    const localSocket = dgram.createSocket('udp4');
+
+    // Store the remote address and port from the Diode client
+    const remoteInfo = {port, address: '127.0.0.1'};
+
+    // Send success response
+    this.rpc.sendResponse(sessionId, ref, 'ok');
+
+    // Store the connection info
+    this.connections.set(ref.toString('hex'), {
+      socket: localSocket,
+      protocol: 'udp',
+      remoteInfo,
+    });
+
+    // Handle messages from the local UDP service
+    localSocket.on('message', (msg, rinfo) => {
+      //need to add 4 bytes of data length to the beginning of the message but it's Big Endian
+      const dataLength = Buffer.alloc(4);
+      dataLength.writeUInt32LE(msg.length, 0);
+      const data = Buffer.concat([dataLength, msg]);
+      // Send the data back to the Diode client via portSend
+      this.rpc.portSend(ref, data);
+    });
+
+    localSocket.on('error', (err) => {
+      console.error(`UDP Socket error:`, err);
+      this.rpc.portClose(ref);
+      this.connections.delete(ref.toString('hex'));
+    });
+  }
+
+  handlePortSend(sessionIdRaw, messageContent) {
+    const refRaw = messageContent[1];
+    const dataRaw = messageContent[2];
+
+    const sessionId = Buffer.from(sessionIdRaw);
+    const ref = Buffer.from(refRaw);
+    const data = Buffer.from(dataRaw).slice(4);
+
+    const connectionInfo = this.connections.get(ref.toString('hex'));
+    if (connectionInfo) {
+      const { socket: localSocket, protocol, remoteInfo } = connectionInfo;
+
+      if (protocol === 'udp') {
+        // Send data to the local UDP service
+        // Since UDP is connectionless, we need to specify the address and port
+        localSocket.send(data, remoteInfo.port, remoteInfo.address, (err) => {
+          if (err) {
+            console.error(`Error sending UDP data:`, err);
+          }
+        });
+
+        // Update remoteInfo if not set
+        if (!localSocket.remoteAddress) {
+          localSocket.remoteAddress = '127.0.0.1'; // Assuming local service is on localhost
+          localSocket.remotePort = port;
+        }
+      } else if (protocol === 'tcp') {
+        // Write data to the local service
+        localSocket.write(data);
+      } else if (protocol === 'tls') {
+        const { diodeSocket } = connectionInfo;
+        // Push data into the DiodeSocket
+        diodeSocket.pushData(data);
+      }
+    } else {
+      console.warn(`No local connection found for ref ${ref.toString('hex')}. Sending portclose.`);
+      this.rpc.sendError(sessionId, ref, 'No local connection found');
+    }
+  }
+
+  handlePortClose(sessionIdRaw, messageContent) {
+    const refRaw = messageContent[1];
+    const sessionId = Buffer.from(sessionIdRaw);
+    const ref = Buffer.from(refRaw);
+
+    console.log(`Received portclose for ref ${ref.toString('hex')}`);
+
+    const connectionInfo = this.connections.get(ref.toString('hex'));
+    if (connectionInfo) {
+      const { diodeSocket, tlsSocket, socket: localSocket } = connectionInfo;
+      // End all sockets
+      if (diodeSocket) diodeSocket.end();
+      if (tlsSocket) tlsSocket.end();
+      if (localSocket) {
+        if (localSocket.type === 'udp4' || localSocket.type === 'udp6') {
+          localSocket.close();
+        } else {
+          localSocket.end();
+        }
+      }
+      this.connections.delete(ref.toString('hex'));
+    }
+  }
+}
+
+module.exports = PublishPort;

package/rpc.js

@@ -0,0 +1,178 @@
+//rpc.js
+const { makeReadable, parseRequestId, parseResponseType, parseReason } = require('./utils');
+
+class DiodeRPC {
+    constructor(connection) {
+      this.connection = connection;
+      this.epochCache = {
+        epoch: null,
+        expiry: null,
+      };
+    }
+  
+    getBlockPeak() {
+        return this.connection.sendCommand(['getblockpeak']).then((responseData) => {
+          // responseData is an array containing [blockNumber]
+          const blockNumberRaw = responseData[0];
+          let blockNumber;
+          if (blockNumberRaw instanceof Uint8Array) {
+            blockNumber = Buffer.from(blockNumberRaw).readUIntBE(0, blockNumberRaw.length);
+          } else if (Buffer.isBuffer(blockNumberRaw)) {
+            blockNumber = blockNumberRaw.readUIntBE(0, blockNumberRaw.length);
+          } else if (typeof blockNumberRaw === 'number') {
+            blockNumber = blockNumberRaw;
+          } else {
+            throw new Error('Invalid block number format. response:', makeReadable(responseData));
+          }
+          return blockNumber;
+        });
+      }
+    getBlockHeader(index) {
+      return this.connection.sendCommand(['getblockheader', index]).then((responseData) => {
+        return responseData[0]; // block_header
+      });
+    }
+  
+    getBlock(index) {
+      return this.connection.sendCommand(['getblock', index]).then((responseData) => {
+        return responseData[0]; // block
+      });
+    }
+  
+    ping() {
+        return this.connection.sendCommand(['ping']).then((responseData) => {
+            // responseData is an array containing [status]
+            const statusRaw = responseData[0];
+            const status = parseResponseType(statusRaw);
+        
+            if (status === 'pong') {
+                return true;
+            } else if (status === 'error') {
+                throw new Error('Ping failed');
+            } else {
+                throw new Error(`Unknown status in response: '${status}'`);
+            }
+            });
+        }
+
+        
+
+    portOpen(deviceId, port, flags = 'rw') {
+        return this.connection.sendCommand(['portopen', deviceId, port, flags]).then((responseData) => {
+          // responseData is [status, refOrReason]
+          const [statusRaw, refOrReasonRaw] = responseData;
+      
+          // Convert status to string
+          const status = parseResponseType(statusRaw);
+      
+          if (status === 'ok') {
+            let ref = refOrReasonRaw;
+            if (Buffer.isBuffer(ref) || ref instanceof Uint8Array) {
+              ref = Buffer.from(ref);
+            }
+            return ref;
+          } else if (status === 'error') {
+            let reason = parseReason(refOrReasonRaw);
+            throw new Error(reason);
+          } else {
+            throw new Error(`Unknown status in response: '${status}'`);
+          }
+        });
+      }
+    
+      async portSend(ref, data) {
+        // Update totalBytes
+        const bytesToSend = data.length;
+        this.connection.totalBytes += bytesToSend;
+    
+        // Now send the data
+        return this.connection.sendCommand(['portsend', ref, data]).then(async (responseData) => {
+          // responseData is [status]
+          const [statusRaw] = responseData;
+          const status = parseResponseType(statusRaw);
+      
+          if (status === 'ok') {
+            try {
+              const ticketCommand = await this.connection.createTicketCommand();
+              const ticketResponse = await this.connection.sendCommand(ticketCommand);
+              console.log('Ticket updated:', ticketResponse);
+            } catch (error) {
+              console.error('Error updating ticket:', error);
+              throw error;
+            }
+            return;
+          } else if (status === 'error') {
+            throw new Error('Error during port send');
+          } else {
+            throw new Error(`Unknown status in response: '${status}'`);
+          }
+        });
+      }
+    
+      portClose(ref) {
+        return this.connection.sendCommand(['portclose', ref]).then((responseData) => {
+          const [statusRaw] = responseData;
+    
+          const status = Buffer.isBuffer(statusRaw) || statusRaw instanceof Uint8Array
+            ? Buffer.from(statusRaw).toString('utf8')
+            : statusRaw;
+    
+          if (status === 'ok') {
+            return;
+          } else if (status === 'error') {
+            throw new Error('Error during port close');
+          } else {
+            throw new Error(`Unknown status in response: '${status}'`);
+          }
+        });
+      }
+
+      sendError(sessionId, ref, error) {
+        return this.connection.sendCommandWithSessionId(['response', ref, 'error', error], sessionId);
+      }
+
+      sendResponse(sessionId, ref, response) {
+        return this.connection.sendCommandWithSessionId(['response', ref, response], sessionId);
+      }
+
+      async getEpoch() {
+        const currentTime = Math.floor(Date.now() / 1000); // Current time in seconds
+        if (this.epochCache.expiry && this.epochCache.expiry > currentTime) {
+          console.log('Using cached epoch:', this.epochCache.epoch);
+          return this.epochCache.epoch;
+        }
+        console.log('Fetching new epoch. Expiry:', this.epochCache.expiry);
+        const blockPeak = await this.getBlockPeak();
+        const blockHeader = await this.getBlockHeader(blockPeak);
+    
+        // Assuming blockHeader is an object with a timestamp property
+        const timestamp = this.parseTimestamp(blockHeader);
+        const epochDuration = 2592000; // 30 days in seconds
+        const epoch = Math.floor(timestamp / epochDuration);
+    
+        // Calculate the time left for the next epoch
+        const timeLeft = epochDuration - (timestamp % epochDuration);
+
+        // Cache the epoch and the expiry time
+        this.epochCache.epoch = epoch;
+        this.epochCache.expiry = currentTime + timeLeft;
+
+        return epoch;
+      }
+    
+      parseTimestamp(blockHeader) {
+        // Implement parsing of timestamp from blockHeader
+        const timestampRaw = blockHeader[0][1]; // Adjust index based on actual structure
+        //Timestamp Raw: [ 'timestamp', 1726689425 ]
+        if (timestampRaw instanceof Uint8Array || Buffer.isBuffer(timestampRaw)) {
+          return Buffer.from(timestampRaw).readUIntBE(0, timestampRaw.length);
+        } else if (typeof timestampRaw === 'number') {
+          return timestampRaw;
+        } else {
+          throw new Error('Invalid timestamp format in block header');
+        }
+      }
+  }
+  
+  module.exports = DiodeRPC;
+  

package/testServers/udpTest.js

@@ -0,0 +1,45 @@
+const dgram = require('dgram');
+const server = dgram.createSocket('udp4');
+
+// emits when any error occurs
+server.on('error',function(error){
+  console.log('Error: ' + error);
+  server.close();
+});
+
+// emits on new datagram msg
+server.on('message',function(msg,info){
+  console.log('Data received from client : ' + msg.toString());
+  console.log('Received %d bytes from %s:%d\n',msg.length, info.address, info.port);
+
+//sending msg
+server.send(msg,info.port,'localhost',function(error){
+  if(error){
+    client.close();
+  }else{
+    console.log('Data sent !!!');
+  }
+
+});
+
+});
+
+//emits when socket is ready and listening for datagram msgs
+server.on('listening',function(){
+  var address = server.address();
+  var port = address.port;
+  var family = address.family;
+  var ipaddr = address.address;
+  console.log('Server is listening at port' + port);
+  console.log('Server ip :' + ipaddr);
+  console.log('Server is IP4/IP6 : ' + family);
+});
+
+//emits after the socket is closed using socket.close();
+server.on('close',function(){
+  console.log('Socket is closed !');
+});
+
+server.bind(8080, () => {
+  console.log('UDP server listening on port 8080');
+});

package/utils.js

@@ -0,0 +1,77 @@
+// utils.js
+const { Buffer } = require('buffer');
+function makeReadable(decodedMessage) {
+  if (Array.isArray(decodedMessage)) {
+    return decodedMessage.map((item) => makeReadable(item));
+  } else if (decodedMessage instanceof Uint8Array) {
+    const buffer = Buffer.from(decodedMessage);
+    // Try to interpret the Buffer as a UTF-8 string
+    const str = buffer.toString('utf8');
+    if (/^[\x20-\x7E]+$/.test(str)) {
+      // If it's printable ASCII, return the string
+      return str;
+    } else if (buffer.length <= 6) {
+      // If it's a small Buffer, interpret it as an integer
+      return buffer.length > 0 && buffer.length <= 6 ? buffer.readUIntBE(0, buffer.length) : '0x' + buffer.toString('hex');
+    } else {
+      // Otherwise, return the hex representation
+      return '0x' + buffer.toString('hex');
+    }
+  } else if (Buffer.isBuffer(decodedMessage)) {
+    // Similar handling for Buffer
+    const str = decodedMessage.toString('utf8');
+    if (/^[\x20-\x7E]+$/.test(str)) {
+      return str;
+    } else if (decodedMessage.length <= 6) {
+      return decodedMessage.readUIntBE(0, decodedMessage.length);
+    } else {
+      return '0x' + decodedMessage.toString('hex');
+    }
+  } else if (typeof decodedMessage === 'number') {
+    return decodedMessage;
+  }
+  return decodedMessage;
+}
+
+// Helper functions
+function parseRequestId(requestIdRaw) {
+  if (requestIdRaw instanceof Uint8Array || Buffer.isBuffer(requestIdRaw)) {
+    const buffer = Buffer.from(requestIdRaw);
+    return buffer.readUIntBE(0, buffer.length);
+  } else if (typeof requestIdRaw === 'number') {
+    return requestIdRaw;
+  } else {
+    return null;
+  }
+}
+
+function parseResponseType(responseTypeRaw) {
+  console.log('responseTypeRaw:', responseTypeRaw);
+  console.log('Type of responseTypeRaw:', typeof responseTypeRaw);
+  console.log('Instance of responseTypeRaw:', responseTypeRaw instanceof Uint8Array);
+  console.log('Is Array:', Array.isArray(responseTypeRaw));
+  if (responseTypeRaw instanceof Uint8Array || Buffer.isBuffer(responseTypeRaw)) {
+    return Buffer.from(responseTypeRaw).toString('utf8');
+  } else if (Array.isArray(responseTypeRaw)) {
+    // Convert each element to Buffer and concatenate
+    const buffers = responseTypeRaw.map((item) => Buffer.from(item));
+    const concatenated = Buffer.concat(buffers);
+    return concatenated.toString('utf8');
+  } else if (typeof responseTypeRaw === 'string') {
+    return responseTypeRaw;
+  } else {
+    throw new Error('Invalid responseType type');
+  }
+}
+
+function parseReason(reasonRaw) {
+  if (Buffer.isBuffer(reasonRaw) || reasonRaw instanceof Uint8Array) {
+    return Buffer.from(reasonRaw).toString('utf8');
+  } else if (typeof reasonRaw === 'string') {
+    return reasonRaw;
+  } else {
+    return '';
+  }
+}
+
+module.exports = { makeReadable, parseRequestId, parseResponseType, parseReason };