@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/src/connection/Handshaker.ts

@@ -1,13 +1,14 @@
 import { Logger } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { v4 } from 'uuid'
-import { Message, HandshakeRequest, HandshakeResponse, MessageType, PeerDescriptor, HandshakeError } from '../proto/packages/dht/protos/DhtRpc'
+import { Message, HandshakeRequest, HandshakeResponse, PeerDescriptor, HandshakeError } from '../proto/packages/dht/protos/DhtRpc'
 import { IConnection } from './IConnection'
+import { LOCAL_PROTOCOL_VERSION, isMaybeSupportedVersion } from '../helpers/version'
 
 const logger = new Logger(module)
 
 interface HandshakerEvents {
-    handshakeRequest: (source: PeerDescriptor, target?: PeerDescriptor) => void
+    handshakeRequest: (source: PeerDescriptor, version: string, target?: PeerDescriptor) => void
     handshakeCompleted: (remote: PeerDescriptor) => void
     handshakeFailed: (error?: HandshakeError) => void
 }
@@ -17,7 +18,7 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
     private localPeerDescriptor: PeerDescriptor
     private connection: IConnection
-
+    private readonly onDataListener: (data: Uint8Array) => void
     constructor(
         localPeerDescriptor: PeerDescriptor,
         connection: IConnection
@@ -25,7 +26,8 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         super()
         this.localPeerDescriptor = localPeerDescriptor
         this.connection = connection
-        this.connection.on('data', (data: Uint8Array) => this.onData(data))
+        this.onDataListener = (data: Uint8Array) => this.onData(data)
+        this.connection.on('data', this.onDataListener)
     }
 
     private onData(data: Uint8Array) {
@@ -34,13 +36,19 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
             if (message.body.oneofKind === 'handshakeRequest') {
                 logger.trace('handshake request received')
                 const handshake = message.body.handshakeRequest
-                this.emit('handshakeRequest', handshake.sourcePeerDescriptor!, handshake.targetPeerDescriptor)
+                this.emit(
+                    'handshakeRequest',
+                    handshake.sourcePeerDescriptor!, 
+                    handshake.version,
+                    handshake.targetPeerDescriptor
+                )
             }
             if (message.body.oneofKind === 'handshakeResponse') {
                 logger.trace('handshake response received')
                 const handshake = message.body.handshakeResponse
-                if (handshake.error !== undefined) {
-                    this.emit('handshakeFailed', handshake.error)
+                const error = !isMaybeSupportedVersion(handshake.version) ? HandshakeError.UNSUPPORTED_VERSION : handshake.error
+                if (error !== undefined) {
+                    this.emit('handshakeFailed', error)
                 } else {
                     this.emit('handshakeCompleted', handshake.sourcePeerDescriptor!)
                 }
@@ -54,11 +62,11 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     public sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void {
         const outgoingHandshake: HandshakeRequest = {
             sourcePeerDescriptor: this.localPeerDescriptor,
-            targetPeerDescriptor: remotePeerDescriptor
+            targetPeerDescriptor: remotePeerDescriptor,
+            version: LOCAL_PROTOCOL_VERSION
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
-            messageType: MessageType.HANDSHAKE_REQUEST,
             messageId: v4(),
             body: {
                 oneofKind: 'handshakeRequest',
@@ -72,11 +80,11 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     public sendHandshakeResponse(error?: HandshakeError): void {
         const outgoingHandshakeResponse: HandshakeResponse = {
             sourcePeerDescriptor: this.localPeerDescriptor,
-            error
+            error,
+            version: LOCAL_PROTOCOL_VERSION
         }
         const msg: Message = {
             serviceId: Handshaker.HANDSHAKER_SERVICE_ID,
-            messageType: MessageType.HANDSHAKE_RESPONSE,
             messageId: v4(),
             body: {
                 oneofKind: 'handshakeResponse',
@@ -86,4 +94,8 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
         this.connection.send(Message.toBinary(msg))
         logger.trace('handshake response sent')
     }
+
+    public stop(): void {
+        this.connection.off('data', this.onDataListener)
+    }
 }

package/src/connection/IConnection.ts

@@ -1,4 +1,4 @@
-import { UUID } from '../helpers/UUID'
+import { BrandedString } from '@streamr/utils'
 
 export interface ConnectionEvents {
     data: (bytes: Uint8Array) => void
@@ -15,13 +15,7 @@ export enum ConnectionType {
     SIMULATOR_CLIENT = 'simulator-client',
 }
 
-export type ConnectionIDKey = string & { readonly __brand: 'connectionIDKey' } // Nominal typing 
-
-export class ConnectionID extends UUID {
-    toMapKey(): ConnectionIDKey {
-        return this.toString() as ConnectionIDKey
-    }
-}
+export type ConnectionID = BrandedString<'ConnectionID'>
 
 export interface IConnection {
     

package/src/connection/ManagedConnection.ts

@@ -4,25 +4,18 @@ import { Handshaker } from './Handshaker'
 import { HandshakeError, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { Logger, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
-import { PeerIDKey } from '../helpers/PeerID'
-import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { createRandomConnectionId } from './Connection'
 
 export interface ManagedConnectionEvents {
     managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void
-    handshakeRequest: (source: PeerDescriptor, target?: PeerDescriptor) => void
+    handshakeRequest: (source: PeerDescriptor, version: string, target?: PeerDescriptor) => void
     handshakeCompleted: (peerDescriptor: PeerDescriptor) => void
     handshakeFailed: () => void
-    bufferSentByOtherConnection: () => void
-    closing: () => void
 }
 
-interface OutpuBufferEvents {
-    bufferSent: () => void
-    bufferSendingFailed: () => void
-}
-
-interface OutpuBufferEvents {
+interface OutputBufferEvents {
     bufferSent: () => void
     bufferSendingFailed: () => void
 }
@@ -34,28 +27,24 @@ export type Events = ManagedConnectionEvents & ConnectionEvents
 export class ManagedConnection extends EventEmitter<Events> {
 
     private implementation?: IConnection
-
-    private outputBufferEmitter = new EventEmitter<OutpuBufferEvents>()
+    private outputBufferEmitter = new EventEmitter<OutputBufferEvents>()
     private outputBuffer: Uint8Array[] = []
-
     private inputBuffer: Uint8Array[] = []
-
     public connectionId: ConnectionID
     private remotePeerDescriptor?: PeerDescriptor
     public connectionType: ConnectionType
-
     private handshaker?: Handshaker
     private handshakeCompleted = false
-
     private lastUsed: number = Date.now()
     private stopped = false
-    public offeredAsIncoming = false
     private bufferSentbyOtherConnection = false
     private closing = false
     public replacedByOtherConnection = false
     private localPeerDescriptor: PeerDescriptor
     protected outgoingConnection?: IConnection
     protected incomingConnection?: IConnection
+    // TODO: Temporary debug variable, should be removed in the future.
+    private created = Date.now()
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
@@ -70,7 +59,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.outgoingConnection = outgoingConnection
         this.incomingConnection = incomingConnection
         this.connectionType = connectionType
-        this.connectionId = new ConnectionID()
+        this.connectionId = createRandomConnectionId()
 
         this.send = this.send.bind(this)
         this.onDisconnected = this.onDisconnected.bind(this)
@@ -84,7 +73,8 @@ export class ManagedConnection extends EventEmitter<Events> {
             this.handshaker = new Handshaker(this.localPeerDescriptor, outgoingConnection)
 
             this.handshaker.once('handshakeFailed', (error) => {
-                if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR) {
+                if (error === HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR || error === HandshakeError.UNSUPPORTED_VERSION) {
+                    // TODO should we have some handling for this floating promise?
                     this.close(false)
                 } else {
                     logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' handshakeFailed: ' + error)
@@ -109,9 +99,13 @@ export class ManagedConnection extends EventEmitter<Events> {
         } else {
             if (incomingConnection) {
                 this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
-                this.handshaker.on('handshakeRequest', (sourcePeerDescriptor: PeerDescriptor, targetPeerDescriptor?: PeerDescriptor) => {
+                this.handshaker.on('handshakeRequest', (
+                    sourcePeerDescriptor: PeerDescriptor,
+                    version: string,
+                    targetPeerDescriptor?: PeerDescriptor
+                ) => {
                     this.setRemotePeerDescriptor(sourcePeerDescriptor)
-                    this.emit('handshakeRequest', sourcePeerDescriptor, targetPeerDescriptor)
+                    this.emit('handshakeRequest', sourcePeerDescriptor, version, targetPeerDescriptor)
                 })
 
                 incomingConnection.on('disconnected', this.onDisconnected)
@@ -162,8 +156,8 @@ export class ManagedConnection extends EventEmitter<Events> {
         return this
     }
 
-    public get peerIdKey(): PeerIDKey {
-        return keyFromPeerDescriptor(this.remotePeerDescriptor!)
+    public getNodeId(): DhtAddress {
+        return getNodeIdFromPeerDescriptor(this.remotePeerDescriptor!)
     }
 
     public getLastUsed(): number {
@@ -183,6 +177,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         this.setRemotePeerDescriptor(peerDescriptor)
         this.handshakeCompleted = true
+        this.handshaker!.stop()
 
         while (this.outputBuffer.length > 0) {
             logger.trace('emptying outputBuffer')
@@ -229,7 +224,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.emit('disconnected', gracefulLeave)
     }
 
-    async send(data: Uint8Array, doNotConnect = false): Promise<void> {
+    async send(data: Uint8Array, connect: boolean): Promise<void> {
         if (this.stopped) {
             throw new Err.SendFailed('ManagedConnection is stopped')
         }
@@ -238,20 +233,25 @@ export class ManagedConnection extends EventEmitter<Events> {
         }
         this.lastUsed = Date.now()
 
-        if (doNotConnect && !this.implementation) {
-            throw new Err.ConnectionNotOpen('Connection not open when calling send() with doNotConnect flag')
+        if (!connect && !this.implementation) {
+            throw new Err.ConnectionNotOpen('Connection not open when calling send() with connect flag as false')
         } else if (this.implementation) {
             this.implementation.send(data)
         } else {
             logger.trace('adding data to outputBuffer')
 
-            let result: RunAndRaceEventsReturnType<OutpuBufferEvents>
+            let result: RunAndRaceEventsReturnType<OutputBufferEvents>
 
             try {
-                result = await runAndRaceEvents3<OutpuBufferEvents>([() => { this.outputBuffer.push(data) }],
-                    this.outputBufferEmitter, ['bufferSent', 'bufferSendingFailed'], 15000)
+                result = await runAndRaceEvents3<OutputBufferEvents>([() => { this.outputBuffer.push(data) }],
+                    this.outputBufferEmitter, ['bufferSent', 'bufferSendingFailed'], 15000)  // TODO use config option or named constant?
             } catch (e) {
-                logger.debug(`Connection to ${getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor)} timed out`)
+                logger.debug(`Connection to ${getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor)} timed out`, {
+                    peerDescriptor: this.remotePeerDescriptor,
+                    type: this.connectionType,
+                    lifetime: Date.now() - this.created
+                })
+                await this.close(false)
                 throw new Err.SendFailed('Sending buffer timed out')
             }
 
@@ -280,7 +280,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         logger.trace('bufferSentByOtherConnection reported')
         this.bufferSentbyOtherConnection = true
         this.outputBufferEmitter.emit('bufferSent')
-        this.emit('bufferSentByOtherConnection')
     }
 
     public acceptHandshake(): void {
@@ -306,13 +305,15 @@ export class ManagedConnection extends EventEmitter<Events> {
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
+        if (this.closing) {
+            return
+        }
         if (this.replacedByOtherConnection) {
             logger.trace('close() called on replaced connection')
         }
         this.closing = true
         
         this.outputBufferEmitter.emit('bufferSendingFailed')
-        this.emit('closing')
        
         if (this.implementation) {
             await this.implementation?.close(gracefulLeave)
@@ -327,8 +328,6 @@ export class ManagedConnection extends EventEmitter<Events> {
 
     public destroy(): void {
         this.closing = true
-        
-        this.emit('closing')
         if (!this.stopped) {
             this.stopped = true
 

package/src/connection/connectivityChecker.ts

@@ -0,0 +1,109 @@
+import { Logger, RunAndRaceEventsReturnType, runAndRaceEvents3 } from '@streamr/utils'
+import { v4 } from 'uuid'
+import * as Err from '../helpers/errors'
+import {
+    ConnectivityRequest, ConnectivityResponse,
+    Message, PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { ConnectionEvents, IConnection } from './IConnection'
+import { ClientWebsocket } from './websocket/ClientWebsocket'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
+import { isMaybeSupportedVersion } from '../helpers/version'
+
+const logger = new Logger(module)
+
+// TODO use config option or named constant?
+export const connectAsync = async ({ url, selfSigned, timeoutMs = 1000 }:
+    { url: string, selfSigned: boolean, timeoutMs?: number }
+): Promise<IConnection> => {
+    const socket = new ClientWebsocket()
+    let result: RunAndRaceEventsReturnType<ConnectionEvents>
+    try {
+        result = await runAndRaceEvents3<ConnectionEvents>([
+            () => { socket.connect(url, selfSigned) }],
+        socket, ['connected', 'error'],
+        timeoutMs)
+    } catch (e) {
+        throw new Err.ConnectionFailed('WebSocket connection timed out')
+    }
+    if (result.winnerName === 'error') {
+        throw new Err.ConnectionFailed('Could not open WebSocket connection')
+    }
+    return socket
+}
+
+export const CONNECTIVITY_CHECKER_SERVICE_ID = 'system/connectivity-checker'
+const CONNECTIVITY_CHECKER_TIMEOUT = 5000
+
+export const sendConnectivityRequest = async (
+    request: ConnectivityRequest,
+    entryPoint: PeerDescriptor
+): Promise<ConnectivityResponse> => {
+    let outgoingConnection: IConnection
+    const wsServerInfo = {
+        host: entryPoint.websocket!.host, 
+        port: entryPoint.websocket!.port,
+        tls: entryPoint.websocket!.tls,
+    }
+    const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityRequest')
+    logger.debug(`Attempting connectivity check with entrypoint ${url}`)
+    try {
+        outgoingConnection = await connectAsync({
+            url,
+            selfSigned: request.selfSigned
+        })
+    } catch (e) {
+        throw new Err.ConnectionFailed(`Failed to connect to entrypoint for connectivity check: ${url}`, e)
+    }
+    // send connectivity request
+    const msg: Message = {
+        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+        messageId: v4(),
+        body: {
+            oneofKind: 'connectivityRequest',
+            connectivityRequest: request
+        }
+    }
+    const responseAwaiter = () => {
+        return new Promise((resolve: (res: ConnectivityResponse) => void, reject) => {
+            const timeoutId = setTimeout(() => {
+                // TODO should we have some handling for this floating promise?
+                outgoingConnection.close(false)
+                reject(new Err.ConnectivityResponseTimeout('timeout'))
+            }, CONNECTIVITY_CHECKER_TIMEOUT)
+            const listener = (bytes: Uint8Array) => {
+                // TODO should we have some handling for this floating promise?
+                outgoingConnection.close(false)
+                try {
+                    const message: Message = Message.fromBinary(bytes)
+                    if (message.body.oneofKind === 'connectivityResponse') {
+                        logger.debug('ConnectivityResponse received: ' + JSON.stringify(Message.toJson(message)))
+                        const connectivityResponseMessage = message.body.connectivityResponse
+                        const remoteVersion = connectivityResponseMessage.version
+                        outgoingConnection!.off('data', listener)
+                        clearTimeout(timeoutId)
+                        if (isMaybeSupportedVersion(remoteVersion)) {
+                            resolve(connectivityResponseMessage)
+                        } else {
+                            reject(`Unsupported version: ${remoteVersion}`)
+                        }
+                    } else {
+                        return
+                    }
+                } catch (err) {
+                    logger.trace(`Could not parse message: ${err}`)
+                }
+            }
+            outgoingConnection!.on('data', listener)
+        })
+    }
+    try {
+        const retPromise = responseAwaiter()
+        outgoingConnection.send(Message.toBinary(msg))
+        logger.trace('ConnectivityRequest sent: ' + JSON.stringify(Message.toJson(msg)))
+        return await retPromise
+    } catch (e) {
+        logger.error('error getting connectivityresponse')
+        throw e
+    }
+}

package/src/connection/connectivityRequestHandler.ts

@@ -0,0 +1,103 @@
+import { ipv4ToNumber, Logger } from '@streamr/utils'
+import { v4 } from 'uuid'
+import {
+    ConnectivityRequest,
+    ConnectivityResponse,
+    Message
+} from '../proto/packages/dht/protos/DhtRpc'
+import { NatType } from './ConnectionManager'
+import { CONNECTIVITY_CHECKER_SERVICE_ID, connectAsync } from './connectivityChecker'
+import { IConnection } from './IConnection'
+import { WebsocketServerConnection } from './websocket/WebsocketServerConnection'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
+import { LOCAL_PROTOCOL_VERSION } from '../helpers/version'
+
+export const DISABLE_CONNECTIVITY_PROBE = 0
+
+const logger = new Logger(module)
+
+export const attachConnectivityRequestHandler = (connectionToListenTo: WebsocketServerConnection): void => {
+    connectionToListenTo.on('data', async (data: Uint8Array) => {
+        logger.trace('server received data')
+        try {
+            const message = Message.fromBinary(data)
+            if (message.body.oneofKind === 'connectivityRequest') {
+                logger.trace('ConnectivityRequest received: ' + JSON.stringify(Message.toJson(message)))
+                try {
+                    await handleIncomingConnectivityRequest(connectionToListenTo, message.body.connectivityRequest)
+                    logger.trace('handleIncomingConnectivityRequest ok')
+                } catch (e) {
+                    logger.error('handleIncomingConnectivityRequest', { error: e })
+                }
+            }
+        } catch (err) {
+            logger.trace(`Could not parse message: ${err}`)
+        }
+    })
+}
+
+const handleIncomingConnectivityRequest = async (connection: WebsocketServerConnection, connectivityRequest: ConnectivityRequest): Promise<void> => {
+    const host = connectivityRequest.host ?? connection.remoteIpAddress
+    const ipAddress = connection.remoteIpAddress
+    let connectivityResponse: ConnectivityResponse
+    if (connectivityRequest.port !== DISABLE_CONNECTIVITY_PROBE) {
+        connectivityResponse = await connectivityProbe(connectivityRequest, ipAddress, host)
+    } else {
+        logger.trace('ConnectivityRequest port is 0, replying without connectivityProbe')
+        connectivityResponse = {
+            host,
+            natType: NatType.UNKNOWN,
+            ipAddress: ipv4ToNumber(ipAddress),
+            version: LOCAL_PROTOCOL_VERSION
+        }
+    }
+    const msg: Message = {
+        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+        messageId: v4(),
+        body: {
+            oneofKind: 'connectivityResponse',
+            connectivityResponse
+        }
+    }
+    connection.send(Message.toBinary(msg))
+    logger.trace('ConnectivityResponse sent: ' + JSON.stringify(Message.toJson(msg)))
+}
+
+const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAddress: string, host: string): Promise<ConnectivityResponse> => {
+    let outgoingConnection: IConnection | undefined
+    let connectivityResponseMessage: ConnectivityResponse
+    try {
+        const wsServerInfo = {
+            host,
+            port: connectivityRequest.port,
+            tls: connectivityRequest.tls
+        }
+        const url = connectivityMethodToWebsocketUrl(wsServerInfo, 'connectivityProbe')
+        logger.trace(`Attempting Connectivity Check to ${url}`)
+        outgoingConnection = await connectAsync({
+            url,
+            selfSigned: connectivityRequest.selfSigned
+        })
+        logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
+        connectivityResponseMessage = {
+            host,
+            natType: NatType.OPEN_INTERNET,
+            websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls },
+            ipAddress: ipv4ToNumber(ipAddress),
+            version: LOCAL_PROTOCOL_VERSION
+        }
+    } catch (err) {
+        logger.debug('error', { err })
+        connectivityResponseMessage = {
+            host,
+            natType: NatType.UNKNOWN,
+            ipAddress: ipv4ToNumber(ipAddress),
+            version: LOCAL_PROTOCOL_VERSION
+        }
+    }
+    if (outgoingConnection) {
+        // TODO should we have some handling for this floating promise?
+        outgoingConnection.close(false)
+    }
+    return connectivityResponseMessage
+}

package/src/connection/simulator/Simulator.ts

@@ -1,6 +1,5 @@
 /* eslint-disable @typescript-eslint/parameter-properties */
 import EventEmitter from 'eventemitter3'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ConnectionSourceEvents } from '../IConnectionSource'
 import { SimulatorConnector } from './SimulatorConnector'
@@ -8,19 +7,9 @@ import { SimulatorConnection } from './SimulatorConnection'
 import { ConnectionID } from '../IConnection'
 import { Logger } from '@streamr/utils'
 import { getRegionDelayMatrix } from './pings'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import Heap from 'heap'
 import { debugVars } from '../../helpers/debugHelpers'
-import * as sinon from 'sinon'
-
-// TODO take this from @streamr/test-utils (we can't access devDependencies as Simulator
-// is currently in "src" directory instead of "test" directory)
-// eslint-disable-next-line no-underscore-dangle
-declare let _streamr_electron_test: any
-export function isRunningInElectron(): boolean {
-    // eslint-disable-next-line no-underscore-dangle
-    return typeof _streamr_electron_test !== 'undefined'
-}
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -102,7 +91,7 @@ class CloseOperation extends SimulatorOperation {
 
 export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     private stopped = false
-    private connectors: Map<PeerIDKey, SimulatorConnector> = new Map()
+    private connectors: Map<DhtAddress, SimulatorConnector> = new Map()
     private latencyTable?: Array<Array<number>>
     private associations: Map<ConnectionID, Association> = new Map()
 
@@ -121,22 +110,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     })
 
     private simulatorTimeout?: NodeJS.Timeout
-    private static clock: sinon.SinonFakeTimers | undefined
-
-    static useFakeTimers(on = true): void {
-        if (!isRunningInElectron()) {  // never use fake timers in browser environment
-            if (on) {
-                if (!Simulator.clock) {
-                    Simulator.clock = sinon.useFakeTimers()
-                }
-            } else {
-                if (Simulator.clock) {
-                    Simulator.clock.restore()
-                    Simulator.clock = undefined
-                }
-            }
-        }
-    }
 
     constructor(latencyType: LatencyType = LatencyType.NONE, fixedLatency?: number) {
         super()
@@ -148,7 +121,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
             this.latencyTable = getRegionDelayMatrix()
         }
 
-        if (this.latencyType === LatencyType.FIXED && !this.fixedLatency) {
+        if ((this.latencyType === LatencyType.FIXED) && (this.fixedLatency === undefined)) {
             throw new Error('LatencyType.FIXED requires the desired latency to be given as second parameter')
         }
 
@@ -185,7 +158,7 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
 
             if (sourceRegion === undefined || targetRegion === undefined || sourceRegion > 15 || targetRegion > 15) {
                 logger.error('invalid region index given to Simulator')
-                throw ('invalid region index given to Simulator')
+                throw new Error('invalid region index given to Simulator')
             }
 
             latency = this.latencyTable![sourceRegion][targetRegion]
@@ -214,11 +187,11 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     }
 
     public addConnector(connector: SimulatorConnector): void {
-        this.connectors.set(keyFromPeerDescriptor(connector.getPeerDescriptor()), connector)
+        this.connectors.set(getNodeIdFromPeerDescriptor(connector.getPeerDescriptor()), connector)
     }
 
     private executeConnectOperation(operation: ConnectOperation): void {
-        const target = this.connectors.get(keyFromPeerDescriptor(operation.targetDescriptor))
+        const target = this.connectors.get(getNodeIdFromPeerDescriptor(operation.targetDescriptor))
 
         if (!target) {
             logger.error('Target connector not found when executing connect operation')
@@ -311,10 +284,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         const timeDifference = firstOperationTime - currentTime
 
         this.simulatorTimeout = setTimeout(this.executeQueuedOperations, timeDifference)
-       
-        if (Simulator.clock) {
-            Simulator.clock.runAllAsync()
-        }
     }
 
     private scheduleOperation(operation: SimulatorOperation) {