@streamr/dht 0.0.1-tatum.1 → 0.0.1-tatum.2

package/src/connection/WebSocket/WebSocketConnector.ts

@@ -4,6 +4,7 @@ import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { RemoteWebSocketConnector } from './RemoteWebSocketConnector'
 import {
+    ConnectivityMethod,
     ConnectivityResponse,
     PeerDescriptor,
     WebSocketConnectionRequest,
@@ -16,7 +17,7 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ManagedConnection } from '../ManagedConnection'
 import { WebSocketServer } from './WebSocketServer'
 import { ConnectivityChecker } from '../ConnectivityChecker'
-import { NatType, PortRange } from '../ConnectionManager'
+import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { ServerWebSocket } from './ServerWebSocket'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
@@ -27,6 +28,12 @@ import { sample } from 'lodash'
 
 const logger = new Logger(module)
 
+export const connectivityMethodToWebSocketUrl = (ws: ConnectivityMethod): string => {
+    return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port
+}
+
+const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
+
 export class WebSocketConnector implements IWebSocketConnectorService {
     private static readonly WEBSOCKET_CONNECTOR_SERVICE_ID = 'system/websocketconnector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
@@ -38,6 +45,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
     private portRange?: PortRange
     private host?: string
     private entrypoints?: PeerDescriptor[]
+    private readonly tlsCertificate?: TlsCertificate
     private selectedPort?: number
     private readonly protocolVersion: string
     private ownPeerDescriptor?: PeerDescriptor
@@ -51,7 +59,8 @@ export class WebSocketConnector implements IWebSocketConnectorService {
         incomingConnectionCallback: (connection: ManagedConnection) => boolean,
         portRange?: PortRange,
         host?: string,
-        entrypoints?: PeerDescriptor[]
+        entrypoints?: PeerDescriptor[],
+        tlsCertificate?: TlsCertificate
     ) {
         this.protocolVersion = protocolVersion
         this.webSocketServer = portRange ? new WebSocketServer() : undefined
@@ -59,6 +68,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
         this.portRange = portRange
         this.host = host
         this.entrypoints = entrypoints
+        this.tlsCertificate = tlsCertificate
 
         this.canConnectFunction = fnCanConnect.bind(this)
 
@@ -101,16 +111,16 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                     this.attachHandshaker(connection)
                 }
             })
-            const port = await this.webSocketServer.start(this.portRange!, this.host)
+            const port = await this.webSocketServer.start(this.portRange!, this.host, this.tlsCertificate)
             this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort)
+            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.tlsCertificate !== undefined)
         }
     }
 
     public async checkConnectivity(reattempt = 0): Promise<ConnectivityResponse> {
         const noServerConnectivityResponse: ConnectivityResponse = {
             openInternet: false,
-            ip: '127.0.0.1',
+            host: '127.0.0.1',
             natType: NatType.UNKNOWN
         }
         if (this.destroyed) {
@@ -125,9 +135,9 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                     // return connectivity info given in config
                     const preconfiguredConnectivityResponse: ConnectivityResponse = {
                         openInternet: true,
-                        ip: this.host!,
+                        host: this.host!,
                         natType: NatType.OPEN_INTERNET,
-                        websocket: { ip: this.host!, port: this.selectedPort! }
+                        websocket: { host: this.host!, port: this.selectedPort!, tls: this.tlsCertificate !== undefined }
                     }
                     return preconfiguredConnectivityResponse
                 } else {
@@ -136,7 +146,8 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                 }
             }
         } catch (err) {
-            if (reattempt < 5) {
+            if (reattempt < ENTRY_POINT_CONNECTION_ATTEMPTS) {
+                logger.error('Failed to connect to the entrypoint', { error: err })
                 await wait(2000)
                 return this.checkConnectivity(reattempt + 1)
             } else {
@@ -158,8 +169,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
         } else {
             const socket = new ClientWebSocket()
 
-            const address = 'ws://' + targetPeerDescriptor.websocket!.ip + ':' +
-                targetPeerDescriptor.websocket!.port
+            const url = connectivityMethodToWebSocketUrl(targetPeerDescriptor.websocket!)
 
             const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion,
                 ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
@@ -177,7 +187,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
             socket.on('disconnected', delFunc)
             managedConnection.on('handshakeCompleted', delFunc)
 
-            socket.connect(address)
+            socket.connect(url)
 
             return managedConnection
         }
@@ -189,7 +199,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
                 targetPeerDescriptor,
                 toProtoRpcClient(new WebSocketConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
             )
-            remoteConnector.requestConnection(ownPeerDescriptor, ownPeerDescriptor.websocket!.ip, ownPeerDescriptor.websocket!.port)
+            remoteConnector.requestConnection(ownPeerDescriptor, ownPeerDescriptor.websocket!.host, ownPeerDescriptor.websocket!.port)
         })
         const managedConnection = new ManagedConnection(this.ownPeerDescriptor!, this.protocolVersion, ConnectionType.WEBSOCKET_SERVER)
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))

package/src/connection/WebSocket/WebSocketServer.ts

@@ -1,4 +1,5 @@
-import * as http from 'http'
+import { createServer as createHttpServer, Server as HttpServer, IncomingMessage, ServerResponse } from 'http'
+import { createServer as createHttpsServer, Server as HttpsServer } from 'https'
 import EventEmitter from 'eventemitter3'
 import { server as WsServer } from 'websocket'
 import { ServerWebSocket } from './ServerWebSocket'
@@ -7,9 +8,10 @@ import {
 } from '../IConnectionSource'
 
 import { Logger, asAbortable } from '@streamr/utils'
-import { StartingWebSocketServerFailed } from '../../helpers/errors'
-import { PortRange } from '../ConnectionManager'
+import { WebSocketServerStartError } from '../../helpers/errors'
+import { PortRange, TlsCertificate } from '../ConnectionManager'
 import { range } from 'lodash'
+import fs from 'fs'
 
 const logger = new Logger(module)
 
@@ -22,30 +24,41 @@ declare class NodeJsWsServer extends WsServer { }
 
 export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
 
-    private httpServer?: http.Server
+    private httpServer?: HttpServer | HttpsServer
     private wsServer?: WsServer
     private readonly abortController = new AbortController()
-    
-    public async start(portRange: PortRange, host?: string): Promise<number> {
+
+    public async start(portRange: PortRange, host?: string, tlsCertificate?: TlsCertificate): Promise<number> {
         const ports = range(portRange.min, portRange.max + 1)
         for (const port of ports) {
             try {
-                await asAbortable(this.startServer(port, host), this.abortController.signal)
+                await asAbortable(this.startServer(port, host, tlsCertificate), this.abortController.signal)
                 return port
             } catch (err) {
-                logger.debug(`failed to start WebSocket server on port: ${port} reattempting on next port`)
+                if (err.originalError?.code === 'EADDRINUSE') {
+                    logger.debug(`failed to start WebSocket server on port: ${port} reattempting on next port`)
+                } else {
+                    throw new WebSocketServerStartError(err)
+                }
             }
         }
-        throw new StartingWebSocketServerFailed('Failed to start WebSocket server on any port in range')
+        throw new WebSocketServerStartError('Failed to start WebSocket server on any port in range')
     }
 
-    private startServer(port: number, host?: string): Promise<void> {
+    private startServer(port: number, host?: string, tlsCertificate?: TlsCertificate): Promise<void> {
+        const requestListener = (request: IncomingMessage, response: ServerResponse<IncomingMessage>) => {
+            logger.trace('Received request for ' + request.url)
+            response.writeHead(404)
+            response.end()
+        }
         return new Promise((resolve, reject) => {
-            this.httpServer = http.createServer((request, response) => {
-                logger.trace('Received request for ' + request.url)
-                response.writeHead(404)
-                response.end()
-            })
+            this.httpServer = tlsCertificate ? 
+                createHttpsServer({
+                    key: fs.readFileSync(tlsCertificate.privateKeyFileName),
+                    cert: fs.readFileSync(tlsCertificate.certFileName)
+                }, requestListener)
+                : 
+                createHttpServer(requestListener)
 
             function originIsAllowed(_uorigin: string) {
                 return true
@@ -67,9 +80,8 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
 
                 this.emit('connected', new ServerWebSocket(connection, request.resourceURL))
             })
-
             this.httpServer.once('error', (err: Error) => {
-                reject(new StartingWebSocketServerFailed('Starting Websocket server failed', err))
+                reject(new WebSocketServerStartError('Starting Websocket server failed', err))
             })
 
             this.httpServer.once('listening', () => {
@@ -80,7 +92,7 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
             try {
                 this.httpServer.listen(port, host)
             } catch (e) {
-                reject(new StartingWebSocketServerFailed('Websocket server threw an exception', e))
+                reject(new WebSocketServerStartError('Websocket server threw an exception', e))
             }
         })
     }
@@ -96,7 +108,7 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
         })
     }
 
-    private createWsServer(httpServer: http.Server): WsServer {
+    private createWsServer(httpServer: HttpServer | HttpsServer): WsServer {
         // Use the real nodejs WebSocket server in Electron tests
 
         if (typeof NodeJsWsServer !== 'undefined') {

package/src/dht/DhtNode.ts

@@ -20,7 +20,7 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import * as Err from '../helpers/errors'
 import { DisconnectionType, ITransport, TransportEvents } from '../transport/ITransport'
-import { ConnectionManager, ConnectionManagerConfig, PortRange } from '../connection/ConnectionManager'
+import { ConnectionManager, ConnectionManagerConfig, PortRange, TlsCertificate } from '../connection/ConnectionManager'
 import { DhtRpcServiceClient, ExternalApiServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     Logger,
@@ -82,6 +82,8 @@ export interface DhtNodeOptions {
     webrtcNewConnectionTimeout?: number
     webrtcPortRange?: PortRange
     maxConnections?: number
+    tlsCertificate?: TlsCertificate
+    externalIp?: string
 }
 
 export class DhtNodeConfig {
@@ -111,7 +113,9 @@ export class DhtNodeConfig {
     webrtcDatachannelBufferThresholdLow?: number
     webrtcDatachannelBufferThresholdHigh?: number
     webrtcNewConnectionTimeout?: number
+    externalIp?: string
     webrtcPortRange?: PortRange
+    tlsCertificate?: TlsCertificate
 
     constructor(conf: Partial<DhtNodeOptions>) {
         // assign given non-undefined config vars over defaults
@@ -132,13 +136,13 @@ export type Events = TransportEvents & DhtNodeEvents
 export const createPeerDescriptor = (msg?: ConnectivityResponse, peerIdString?: string, nodeName?: string): PeerDescriptor => {
     let peerId: Uint8Array
     if (msg) {
-        peerId = peerIdString ? PeerID.fromString(peerIdString).value : PeerID.fromIp(msg.ip).value
+        peerId = peerIdString ? PeerID.fromString(peerIdString).value : PeerID.fromIp(msg.host).value
     } else {
         peerId = PeerID.fromString(peerIdString!).value
     }
     const ret: PeerDescriptor = { kademliaId: peerId, nodeName: nodeName, type: NodeType.NODEJS }
     if (msg && msg.websocket) {
-        ret.websocket = { ip: msg.websocket.ip, port: msg.websocket.port }
+        ret.websocket = { host: msg.websocket.host, port: msg.websocket.port, tls: msg.websocket.tls }
         ret.openInternet = true
     }
     return ret
@@ -208,11 +212,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 webrtcNewConnectionTimeout: this.config.webrtcNewConnectionTimeout,
                 webrtcPortRange: this.config.webrtcPortRange,
                 nodeName: this.getNodeName(),
-                maxConnections: this.config.maxConnections
+                maxConnections: this.config.maxConnections,
+                tlsCertificate: this.config.tlsCertificate,
+                externalIp: this.config.externalIp
             }
             // If own PeerDescriptor is given in config, create a ConnectionManager with ws server
             if (this.config.peerDescriptor?.websocket) {
-                connectionManagerConfig.websocketHost = this.config.peerDescriptor.websocket.ip
+                connectionManagerConfig.websocketHost = this.config.peerDescriptor.websocket.host
                 connectionManagerConfig.websocketPortRange = { 
                     min: this.config.peerDescriptor.websocket.port,
                     max: this.config.peerDescriptor.websocket.port
@@ -619,12 +625,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         await this.router!.send(msg, reachableThrough)
     }
 
-    public async joinDht(entryPointDescriptors: PeerDescriptor[], doRandomJoin?: boolean): Promise<void> {
+    public async joinDht(entryPointDescriptors: PeerDescriptor[], doRandomJoin?: boolean, retry?: boolean): Promise<void> {
         if (!this.started) {
             throw new Error('Cannot join DHT before calling start() on DhtNode')
         }
         await Promise.all(entryPointDescriptors.map((entryPoint) => 
-            this.peerDiscovery!.joinDht(entryPoint, doRandomJoin)
+            this.peerDiscovery!.joinDht(entryPoint, doRandomJoin, retry)
         ))
     }
 

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,7 +1,6 @@
 import { DiscoverySession } from './DiscoverySession'
 import { DhtPeer } from '../DhtPeer'
 import crypto from 'crypto'
-import * as Err from '../../helpers/errors'
 import { isSamePeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
@@ -41,13 +40,14 @@ export class PeerDiscovery {
 
     private rejoinTimeoutRef?: NodeJS.Timeout
     private readonly abortController: AbortController
+    private recoveryIntervalStarted = false
 
     constructor(config: PeerDiscoveryConfig) {
         this.config = config
         this.abortController = new AbortController()
     }
 
-    async joinDht(entryPointDescriptor: PeerDescriptor, doRandomJoin = true): Promise<void> {
+    async joinDht(entryPointDescriptor: PeerDescriptor, doRandomJoin = true, retry = true): Promise<void> {
         if (this.stopped) {
             return
         }
@@ -90,16 +90,18 @@ export class PeerDiscovery {
             if (randomSession) {
                 await randomSession.findClosestNodes(this.config.joinTimeout)
             }
+        } catch (_e) {
+            logger.debug(`DHT join on ${this.config.serviceId} timed out`)
+        } finally {
             if (!this.stopped) {
                 if (this.config.bucket.count() === 0) {
-                    this.rejoinDht(entryPointDescriptor).catch(() => {})
+                    if (retry) {
+                        setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
+                    }
                 } else {
-                    await scheduleAtInterval(() => this.getClosestPeersFromBucket(), 60000, true, this.abortController.signal)
+                    await this.ensureRecoveryIntervalIsRunning()
                 }
             }
-        } catch (_e) {
-            throw new Err.DhtJoinTimeout('join timed out')
-        } finally {
             this.ongoingDiscoverySessions.delete(session.sessionId)
             if (randomSession) {
                 this.ongoingDiscoverySessions.delete(randomSession.sessionId)
@@ -128,7 +130,14 @@ export class PeerDiscovery {
         }
     }
 
-    private async getClosestPeersFromBucket(): Promise<void> {
+    private async ensureRecoveryIntervalIsRunning(): Promise<void> {
+        if (!this.recoveryIntervalStarted) {
+            this.recoveryIntervalStarted = true
+            await scheduleAtInterval(() => this.fetchClosestPeersFromBucket(), 60000, true, this.abortController.signal)
+        }
+    }
+
+    private async fetchClosestPeersFromBucket(): Promise<void> {
         if (this.stopped) {
             return
         }

package/src/exports.ts

@@ -5,7 +5,7 @@ export { SimulatorTransport } from './connection/Simulator/SimulatorTransport'
 export { getRandomRegion, getRegionDelayMatrix } from './connection/Simulator/pings'
 export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
 export { ITransport } from './transport/ITransport'
-export { ConnectionManager, ConnectionLocker, PortRange } from './connection/ConnectionManager'
+export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
 export { PeerID, PeerIDKey } from './helpers/PeerID'
 export { DhtPeer } from './dht/DhtPeer'
 export { UUID } from './helpers/UUID'

package/src/helpers/errors.ts

@@ -33,7 +33,7 @@ class Err extends Error {
 
 export class ConnectionFailed extends Err { constructor( message?: string, originalError?: Error | string) { super(ErrorCode.CONNECTION_FAILED, message, originalError) } }
 export class CouldNotRoute extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_ROUTE, message, originalError) } }
-export class StartingWebSocketServerFailed extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.STARTING_WEBSOCKET_SERVER_FAILED, message, originalError) } }
+export class WebSocketServerStartError extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.STARTING_WEBSOCKET_SERVER_FAILED, message, originalError) } }
 export class WebSocketConnectionRequestRejected extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.WEBSOCKET_CONNECTION_REQUEST_REJECTED, message, originalError) } }
 export class CouldNotStart extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_START, message, originalError) } }
 export class CouldNotStop extends Err { constructor(message?: string, originalError?: Error | string) { super(ErrorCode.COULD_NOT_STOP, message, originalError) } }

package/src/helpers/protoClasses.ts

@@ -2,9 +2,7 @@ import { IMessageType } from '@protobuf-ts/runtime'
 import {
     ClosestPeersRequest,
     ClosestPeersResponse, 
-    ConnectivityMethod, 
-    ConnectivityReportRequest, 
-    ConnectivityReportResponse, 
+    ConnectivityMethod,  
     ConnectivityRequest, 
     ConnectivityResponse, 
     DisconnectNotice,
@@ -41,8 +39,6 @@ export const protoClasses: Array<IMessageType<any>> = [
     LeaveNotice,
     PeerDescriptor,
     ConnectivityMethod,
-    ConnectivityReportRequest,
-    ConnectivityReportResponse,
     DisconnectNotice,
     RouteMessageWrapper,
     RouteMessageAck,

package/src/proto/google/protobuf/any.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/proto/google/protobuf/empty.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/proto/google/protobuf/timestamp.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { ExternalApiService } from "./DhtRpc";

package/src/proto/packages/dht/protos/DhtRpc.server.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { FindDataResponse } from "./DhtRpc";

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { Empty } from "../../../google/protobuf/empty";
@@ -240,48 +240,18 @@ export interface PeerDescriptor {
  * @generated from protobuf message dht.ConnectivityMethod
  */
 export interface ConnectivityMethod {
-    /**
-     * @generated from protobuf field: uint32 port = 2;
-     */
-    port: number;
-    /**
-     * @generated from protobuf field: string ip = 3;
-     */
-    ip: string;
-}
-/**
- * @generated from protobuf message dht.ConnectivityReportRequest
- */
-export interface ConnectivityReportRequest {
     /**
      * @generated from protobuf field: uint32 port = 1;
      */
     port: number;
     /**
-     * @generated from protobuf field: string requestId = 2;
-     */
-    requestId: string;
-}
-/**
- * @generated from protobuf message dht.ConnectivityReportResponse
- */
-export interface ConnectivityReportResponse {
-    /**
-     * @generated from protobuf field: string open_internet = 1;
-     */
-    openInternet: string;
-    /**
-     * @generated from protobuf field: string ip = 2;
-     */
-    ip: string;
-    /**
-     * @generated from protobuf field: string natType = 3;
+     * @generated from protobuf field: string host = 2;
      */
-    natType: string;
+    host: string;
     /**
-     * @generated from protobuf field: string requestId = 4;
+     * @generated from protobuf field: bool tls = 3;
      */
-    requestId: string;
+    tls: boolean;
 }
 /**
  * @generated from protobuf message dht.RouteMessageWrapper
@@ -347,6 +317,10 @@ export interface ConnectivityRequest {
      * @generated from protobuf field: uint32 port = 1;
      */
     port: number;
+    /**
+     * @generated from protobuf field: bool tls = 2;
+     */
+    tls: boolean;
 }
 /**
  * @generated from protobuf message dht.ConnectivityResponse
@@ -357,9 +331,9 @@ export interface ConnectivityResponse {
      */
     openInternet: boolean;
     /**
-     * @generated from protobuf field: string ip = 2;
+     * @generated from protobuf field: string host = 2;
      */
-    ip: string;
+    host: string;
     /**
      * @generated from protobuf field: string natType = 3;
      */
@@ -1007,8 +981,9 @@ export const PeerDescriptor = new PeerDescriptor$Type();
 class ConnectivityMethod$Type extends MessageType$<ConnectivityMethod> {
     constructor() {
         super("dht.ConnectivityMethod", [
-            { no: 2, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
-            { no: 3, name: "ip", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "tls", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
 }
@@ -1017,34 +992,6 @@ class ConnectivityMethod$Type extends MessageType$<ConnectivityMethod> {
  */
 export const ConnectivityMethod = new ConnectivityMethod$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ConnectivityReportRequest$Type extends MessageType$<ConnectivityReportRequest> {
-    constructor() {
-        super("dht.ConnectivityReportRequest", [
-            { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
-            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
-        ]);
-    }
-}
-/**
- * @generated MessageType for protobuf message dht.ConnectivityReportRequest
- */
-export const ConnectivityReportRequest = new ConnectivityReportRequest$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class ConnectivityReportResponse$Type extends MessageType$<ConnectivityReportResponse> {
-    constructor() {
-        super("dht.ConnectivityReportResponse", [
-            { no: 1, name: "open_internet", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "ip", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 3, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 4, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
-        ]);
-    }
-}
-/**
- * @generated MessageType for protobuf message dht.ConnectivityReportResponse
- */
-export const ConnectivityReportResponse = new ConnectivityReportResponse$Type();
-// @generated message type with reflection information, may provide speed optimized methods
 class RouteMessageWrapper$Type extends MessageType$<RouteMessageWrapper> {
     constructor() {
         super("dht.RouteMessageWrapper", [
@@ -1081,7 +1028,8 @@ export const RouteMessageAck = new RouteMessageAck$Type();
 class ConnectivityRequest$Type extends MessageType$<ConnectivityRequest> {
     constructor() {
         super("dht.ConnectivityRequest", [
-            { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+            { no: 1, name: "port", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "tls", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
 }
@@ -1094,7 +1042,7 @@ class ConnectivityResponse$Type extends MessageType$<ConnectivityResponse> {
     constructor() {
         super("dht.ConnectivityResponse", [
             { no: 1, name: "open_internet", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
-            { no: 2, name: "ip", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "host", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "natType", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 4, name: "websocket", kind: "message", T: () => ConnectivityMethod }
         ]);

package/src/proto/packages/proto-rpc/protos/ProtoRpc.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/proto-rpc/protos/ProtoRpc.proto" (package "protorpc", syntax proto3)
 // tslint:disable
 import { MessageType } from "@protobuf-ts/runtime";

package/test/end-to-end/Layer0-Layer1.test.ts

@@ -6,7 +6,7 @@ describe('Layer0-Layer1', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: Uint8Array.from([1, 2, 3]),
         type: NodeType.NODEJS,
-        websocket: { ip: '127.0.0.1', port: 10016 }
+        websocket: { host: '127.0.0.1', port: 10016, tls: false }
     }
 
     const STREAM_ID1 = 'stream1'

package/test/end-to-end/Layer0.test.ts

@@ -6,7 +6,7 @@ describe('Layer0', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: Uint8Array.from([1, 2, 3]),
         type: NodeType.NODEJS,
-        websocket: { ip: '127.0.0.1', port: 10011 }
+        websocket: { host: '127.0.0.1', port: 10011, tls: false }
     }
     
     let epDhtNode: DhtNode

package/test/end-to-end/Layer0MixedConnectionTypes.test.ts

@@ -8,7 +8,7 @@ describe('Layer0MixedConnectionTypes', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: Uint8Array.from([1, 2, 3]),
         type: NodeType.NODEJS,
-        websocket: { ip: '127.0.0.1', port: 11221 }
+        websocket: { host: '127.0.0.1', port: 11221, tls: false }
     }
 
     let epDhtNode: DhtNode

package/test/end-to-end/Layer0WebRTC-Layer1.test.ts

@@ -9,8 +9,9 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         kademliaId: PeerID.fromString(entryPointId).value,
         type: NodeType.NODEJS,
         websocket: {
-            ip: '127.0.0.1',
-            port: 23232
+            host: '127.0.0.1',
+            port: 23232,
+            tls: false
         }
     }
 

package/test/end-to-end/Layer0WebRTC.test.ts

@@ -11,7 +11,7 @@ describe('Layer0 with WebRTC connections', () => {
         kademliaId: PeerID.fromString('entrypoint').value,
         nodeName: 'entrypoint',
         type: NodeType.NODEJS,
-        websocket: { ip: '127.0.0.1', port: 10029 }
+        websocket: { host: '127.0.0.1', port: 10029, tls: false }
     }
     let epDhtNode: DhtNode
     let node1: DhtNode