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

package/src/connection/WebRTC/WebRtcConnector.ts

@@ -28,6 +28,15 @@ import { PortRange } from '../ConnectionManager'
 
 const logger = new Logger(module)
 
+export const replaceInternalIpWithExternalIp = (candidate: string, ip: string): string => {
+    const parsed = candidate.split(' ')
+    const type = parsed[7]
+    if (type === 'host') {
+        parsed[4] = ip
+    }
+    return parsed.join(' ')
+}
+
 export interface WebRtcConnectorConfig {
     rpcTransport: ITransport
     protocolVersion: string
@@ -36,6 +45,7 @@ export interface WebRtcConnectorConfig {
     bufferThresholdLow?: number
     bufferThresholdHigh?: number
     connectionTimeout?: number
+    externalIp?: string
     portRange?: PortRange
 }
 
@@ -131,6 +141,10 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {
+            if (this.config.externalIp) {
+                candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
+                logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
+            }
             remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection.connectionId.toString())
         })
 

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,17 @@ 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.tlsCertificate)
             this.selectedPort = port
-            this.connectivityChecker = new ConnectivityChecker(this.selectedPort)
+            this.connectivityChecker = new ConnectivityChecker(this.selectedPort, this.tlsCertificate !== undefined, this.host)
         }
     }
 
     public async checkConnectivity(reattempt = 0): Promise<ConnectivityResponse> {
+        // TODO: this could throw if the server is not running
         const noServerConnectivityResponse: ConnectivityResponse = {
             openInternet: false,
-            ip: '127.0.0.1',
+            host: '127.0.0.1',
             natType: NatType.UNKNOWN
         }
         if (this.destroyed) {
@@ -125,9 +136,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 +147,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 +170,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 +188,7 @@ export class WebSocketConnector implements IWebSocketConnectorService {
             socket.on('disconnected', delFunc)
             managedConnection.on('handshakeCompleted', delFunc)
 
-            socket.connect(address)
+            socket.connect(url)
 
             return managedConnection
         }
@@ -189,7 +200,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, 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, 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: ${portRange.min}-${portRange.min}`)
     }
 
-    private startServer(port: number, host?: string): Promise<void> {
+    private startServer(port: number, 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', () => {
@@ -78,9 +90,10 @@ export class WebSocketServer extends EventEmitter<ConnectionSourceEvents> {
             })
 
             try {
-                this.httpServer.listen(port, host)
+                // Listen only to IPv4 network interfaces, default value listens to IPv6 as well
+                this.httpServer.listen(port, '0.0.0.0')
             } catch (e) {
-                reject(new StartingWebSocketServerFailed('Websocket server threw an exception', e))
+                reject(new WebSocketServerStartError('Websocket server threw an exception', e))
             }
         })
     }
@@ -96,7 +109,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,11 +20,13 @@ 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,
-    MetricsContext
+    MetricsContext,
+    hexToBinary,
+    binaryToHex
 } from '@streamr/utils'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { RandomContactList } from './contact/RandomContactList'
@@ -71,7 +73,7 @@ export interface DhtNodeOptions {
     entryPoints?: PeerDescriptor[]
     websocketHost?: string
     websocketPortRange?: PortRange
-    peerIdString?: string
+    peerId?: string
 
     nodeName?: string
     rpcRequestTimeout?: number
@@ -82,6 +84,8 @@ export interface DhtNodeOptions {
     webrtcNewConnectionTimeout?: number
     webrtcPortRange?: PortRange
     maxConnections?: number
+    tlsCertificate?: TlsCertificate
+    externalIp?: string
 }
 
 export class DhtNodeConfig {
@@ -97,7 +101,7 @@ export class DhtNodeConfig {
     storeMaxTtl = 60000
     storeNumberOfCopies = 5
     metricsContext = new MetricsContext()
-    peerIdString = new UUID().toHex()
+    peerId = new UUID().toHex()
 
     transportLayer?: ITransport
     peerDescriptor?: PeerDescriptor
@@ -111,7 +115,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
@@ -129,16 +135,16 @@ const logger = new Logger(module)
 
 export type Events = TransportEvents & DhtNodeEvents
 
-export const createPeerDescriptor = (msg?: ConnectivityResponse, peerIdString?: string, nodeName?: string): PeerDescriptor => {
-    let peerId: Uint8Array
+export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string, nodeName?: string): PeerDescriptor => {
+    let kademliaId: Uint8Array
     if (msg) {
-        peerId = peerIdString ? PeerID.fromString(peerIdString).value : PeerID.fromIp(msg.ip).value
+        kademliaId = peerId ? hexToBinary(peerId) : PeerID.fromIp(msg.host).value
     } else {
-        peerId = PeerID.fromString(peerIdString!).value
+        kademliaId = hexToBinary(peerId!)
     }
-    const ret: PeerDescriptor = { kademliaId: peerId, nodeName: nodeName, type: NodeType.NODEJS }
+    const ret: PeerDescriptor = { kademliaId, nodeName: nodeName ? nodeName : binaryToHex(kademliaId), 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
@@ -207,12 +213,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 webrtcDatachannelBufferThresholdHigh: this.config.webrtcDatachannelBufferThresholdHigh,
                 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
@@ -442,7 +449,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             this.ownPeerDescriptor = this.config.peerDescriptor
         } else {
             this.ownPeerDescriptor = createPeerDescriptor(connectivityResponse,
-                this.config.peerIdString,
+                this.config.peerId,
                 this.config.nodeName)
         }
         return this.ownPeerDescriptor
@@ -619,12 +626,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)
         ))
     }
 
@@ -700,14 +707,6 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return this.connectionManager!.getNumberOfWeakLockedConnections()
     }
 
-    public getNodeName(): string {
-        if (this.config.nodeName) {
-            return this.config.nodeName
-        } else {
-            return 'unnamed node'
-        }
-    }
-
     public isJoinOngoing(): boolean {
         return this.peerDiscovery!.isJoinOngoing()
     }

package/src/dht/DhtPeer.ts

@@ -69,7 +69,7 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
                 return true
             }
         } catch (err) {
-            logger.debug(`ping failed on ${this.serviceId} to ${this.peerId.toKey()}: ${err}`)
+            logger.trace(`ping failed on ${this.serviceId} to ${this.peerId.toKey()}: ${err}`)
         }
         return false
     }

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/dht/routing/RemoteRouter.ts

@@ -30,9 +30,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
             timeout: 10000
         }
         try {
-            logger.trace('calling dhtClient.routeMessage')
             const ack = await this.client.routeMessage(message, options)
-            logger.trace('dhtClient.routeMessage returned')
             // Success signal if sent to destination and error includes duplicate
             if (
                 isSamePeerDescriptor(params.destinationPeer!, this.peerDescriptor)
@@ -45,7 +43,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
         } catch (err) {
             const fromNode = params.previousPeer ?
                 peerIdFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
-            logger.debug(`Failed to send routeMessage from ${fromNode} to ${this.peerId.toKey()} with: ${err}`)
+            logger.trace(`Failed to send routeMessage from ${fromNode} to ${this.peerId.toKey()} with: ${err}`)
             return false
         }
         return true
@@ -75,7 +73,7 @@ export class RemoteRouter extends Remote<IRoutingServiceClient> {
             const fromNode = params.previousPeer ?
                 keyFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
 
-            logger.debug(
+            logger.trace(
                 `Failed to send forwardMessage from ${fromNode} to ${this.peerId.toKey()} with: ${err}`
             )
             return false

package/src/dht/store/DataStore.ts

@@ -136,10 +136,10 @@ export class DataStore implements IStoreService {
         try {
             const response = await remoteStore.migrateData({ dataEntry }, doNotConnect)
             if (response.error) {
-                logger.debug('RemoteStore::migrateData() returned error: ' + response.error)
+                logger.trace('RemoteStore::migrateData() returned error: ' + response.error)
             }
         } catch (e) {
-            logger.debug('RemoteStore::migrateData() threw an exception ' + e)
+            logger.trace('RemoteStore::migrateData() threw an exception ' + e)
         }
     }
 
@@ -177,10 +177,10 @@ export class DataStore implements IStoreService {
                     successfulNodes.push(closestNodes[i])
                     logger.trace('remoteStore.storeData() returned success')
                 } else {
-                    logger.debug('remoteStore.storeData() returned error: ' + response.error)
+                    logger.trace('remoteStore.storeData() returned error: ' + response.error)
                 }
             } catch (e) {
-                logger.debug('remoteStore.storeData() threw an exception ' + e)
+                logger.trace('remoteStore.storeData() threw an exception ' + e)
             }
         }
         return successfulNodes
@@ -217,11 +217,11 @@ export class DataStore implements IStoreService {
                 if (response.deleted) {
                     logger.trace('remoteStore.deleteData() returned success')
                 } else {
-                    logger.debug('could not delete data from ' + PeerID.fromValue(closestNodes[i].kademliaId))
+                    logger.trace('could not delete data from ' + PeerID.fromValue(closestNodes[i].kademliaId))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {
-                logger.debug('remoteStore.deleteData() threw an exception ' + e)
+                logger.trace('remoteStore.deleteData() threw an exception ' + e)
             }
         }
     }

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";