@streamr/dht 100.2.5-beta.1 → 101.0.0-beta.0

package/src/connection/ManagedConnection.ts

@@ -1,8 +1,7 @@
-import { ConnectionEvents, ConnectionID, ConnectionType, IConnection } from './IConnection'
+import { ConnectionID, IConnection } from './IConnection'
 import * as Err from '../helpers/errors'
-import { Handshaker } from './Handshaker'
-import { HandshakeError, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
-import { Logger, runAndRaceEvents3, RunAndRaceEventsReturnType } from '@streamr/utils'
+import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
@@ -10,342 +9,80 @@ import { createRandomConnectionId } from './Connection'
 
 export interface ManagedConnectionEvents {
     managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void
-    handshakeRequest: (source: PeerDescriptor, version: string, target?: PeerDescriptor) => void
-    handshakeCompleted: (peerDescriptor: PeerDescriptor) => void
-    handshakeFailed: () => void
-}
-
-interface OutputBufferEvents {
-    bufferSent: () => void
-    bufferSendingFailed: () => void
+    disconnected: (gracefulLeave: boolean) => void
 }
 
 const logger = new Logger(module)
 
-export type Events = ManagedConnectionEvents & ConnectionEvents
+export type Events = ManagedConnectionEvents
 
-export class ManagedConnection extends EventEmitter<Events> {
+// ManagedConnection is a component used as a wrapper for IConnection after they have been successfully handshaked.
+// Should only be used in the ConnectionManager.
+export class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
 
-    private implementation?: IConnection
-    private outputBufferEmitter = new EventEmitter<OutputBufferEvents>()
-    private outputBuffer: Uint8Array[] = []
-    private inputBuffer: Uint8Array[] = []
+    private connection: IConnection
     public connectionId: ConnectionID
-    private remotePeerDescriptor?: PeerDescriptor
-    public connectionType: ConnectionType
-    private handshaker?: Handshaker
-    private handshakeCompleted = false
+    private remotePeerDescriptor: PeerDescriptor
     private lastUsedTimestamp: number = Date.now()
+    private replacedAsDuplicate = false
     private stopped = 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,
-        connectionType: ConnectionType,
-        outgoingConnection?: IConnection,
-        incomingConnection?: IConnection,
-        targetPeerDescriptor?: PeerDescriptor
-    ) {
+    constructor(peerDescriptor: PeerDescriptor, connection: IConnection) {
         super()
-
-        this.localPeerDescriptor = localPeerDescriptor
-        this.outgoingConnection = outgoingConnection
-        this.incomingConnection = incomingConnection
-        this.connectionType = connectionType
         this.connectionId = createRandomConnectionId()
+        this.connection = connection
 
-        this.send = this.send.bind(this)
-        this.onDisconnected = this.onDisconnected.bind(this)
-
-        logger.trace('creating ManagedConnection of type: ' + connectionType)
-        if (incomingConnection && outgoingConnection) {
-            throw new Err.IllegalArguments('Managed connection constructor only accepts either an incoming connection OR a outgoing connection')
-        }
-
-        if (outgoingConnection) {
-            this.handshaker = new Handshaker(this.localPeerDescriptor, outgoingConnection)
-
-            this.handshaker.once('handshakeFailed', (error) => {
-                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)
-                    this.emit('handshakeFailed')
-                }
-            })
-
-            this.handshaker.on('handshakeCompleted', (peerDescriptor: PeerDescriptor) => {
-                logger.trace('handshake completed for outgoing connection '
-                    + ', ' + getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) 
-                    + ' outputBuffer.length: ' + this.outputBuffer.length)
-                this.attachImplementation(outgoingConnection)
-                this.onHandshakeCompleted(peerDescriptor)
-            })
-
-            outgoingConnection.once('connected', () => {
-                this.handshaker!.sendHandshakeRequest(targetPeerDescriptor)
-                this.emit('connected')
-            })
-            outgoingConnection.once('disconnected', this.onDisconnected)
-
-        } else if (incomingConnection) {
-            this.handshaker = new Handshaker(this.localPeerDescriptor, incomingConnection)
-            this.handshaker.on('handshakeRequest', (
-                sourcePeerDescriptor: PeerDescriptor,
-                version: string,
-                targetPeerDescriptor?: PeerDescriptor
-            ) => {
-                this.setRemotePeerDescriptor(sourcePeerDescriptor)
-                this.emit('handshakeRequest', sourcePeerDescriptor, version, targetPeerDescriptor)
-            })
-
-            incomingConnection.on('disconnected', this.onDisconnected)
-        }
-    }
-
-    // eventemitter3 does not implement the standard 'newListener' event, so we need to override
-
-    override on(
-        event: keyof Events,
-        fn: (...args: any) => void,
-        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-        context?: any
-    ): this {
-        if (event === 'managedData' && this.listenerCount('managedData') === 0) {
-            while (this.inputBuffer.length > 0) {
-                logger.trace('emptying inputBuffer')
-                const data = this.inputBuffer.shift()!
-                fn(data, this.getPeerDescriptor())
-            }
-        }
-        super.on(event, fn, context)
-        return this
-    }
-
-    override once(
-        event: keyof Events,
-        fn: (...args: any) => void,
-        // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-        context?: any
-    ): this {
-        if (event === 'managedData' && this.listenerCount('managedData') === 0) {
-            if (this.inputBuffer.length > 0) {
-                while (this.inputBuffer.length > 0) {
-                    logger.trace('emptying inputBuffer')
-                    const data = this.inputBuffer.shift()!
-                    fn(data, this.getPeerDescriptor())
-                }
-            } else {
-                super.once(event, fn, context)
-            }
-        } else {
-            super.once(event, fn, context)
-        }
-
-        return this
-    }
-
-    public getNodeId(): DhtAddress {
-        return getNodeIdFromPeerDescriptor(this.remotePeerDescriptor!)
-    }
-
-    public getLastUsedTimestamp(): number {
-        return this.lastUsedTimestamp
-    }
-
-    public setRemotePeerDescriptor(peerDescriptor: PeerDescriptor): void {
-        this.remotePeerDescriptor = peerDescriptor
-    }
-
-    public getPeerDescriptor(): PeerDescriptor | undefined {
-        return this.remotePeerDescriptor
-    }
-
-    private onHandshakeCompleted(peerDescriptor: PeerDescriptor) {
-        this.lastUsedTimestamp = Date.now()
-
-        this.setRemotePeerDescriptor(peerDescriptor)
-        this.handshakeCompleted = true
-        this.handshaker!.stop()
-
-        while (this.outputBuffer.length > 0) {
-            logger.trace('emptying outputBuffer')
-            this.implementation!.send(this.outputBuffer.shift()!)
-        }
-        this.outputBufferEmitter.emit('bufferSent')
-        logger.trace('emitting handshake_completed')
-        this.emit('handshakeCompleted', peerDescriptor)
-    }
-
-    public attachImplementation(impl: IConnection): void {
-        logger.trace('attachImplementation()')
-        this.implementation = impl
-
-        impl.on('data', (bytes: Uint8Array) => {
+        connection.on('data', (bytes: Uint8Array) => {
             this.lastUsedTimestamp = Date.now()
-            if (this.listenerCount('managedData') === 0) {
-                this.inputBuffer.push(bytes)
-            } else {
-                this.emit('managedData', bytes, this.getPeerDescriptor()!)
-            }
+            this.emit('managedData', bytes, this.getPeerDescriptor()!)
         })
+        connection.on('disconnected', (gracefulLeave) => this.onDisconnected(gracefulLeave))
 
-        impl.on('error', (name: string) => {
-            this.emit('error', name)
-        })
-        impl.on('connected', () => {
-            this.lastUsedTimestamp = Date.now()
-            logger.trace('connected emitted')
-            this.emit('connected')
-        })
-
-        //ensure that we have subscribed to the event only once
-        impl.off('disconnected', this.onDisconnected)
-        impl.on('disconnected', this.onDisconnected)
+        this.lastUsedTimestamp = Date.now()
+        this.remotePeerDescriptor = peerDescriptor
     }
 
     private onDisconnected(gracefulLeave: boolean): void {
         logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' onDisconnected() ' + gracefulLeave)
-        if (this.bufferSentbyOtherConnection) {
-            return
+        if (!this.replacedAsDuplicate) {
+            this.emit('disconnected', gracefulLeave)
         }
-        this.outputBufferEmitter.emit('bufferSendingFailed')
-        this.emit('disconnected', gracefulLeave)
+        this.removeAllListeners()
+    }
+
+    // TODO: Can this be removed if ManagedConnections can never be duplicates?
+    // Handle duplicates in the ConncetorFacade and no longer have PendingConnections in ConnectionManager
+    replaceAsDuplicate(): void {
+        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate')
+        this.replacedAsDuplicate = true
     }
 
-    async send(data: Uint8Array, connect: boolean): Promise<void> {
+    send(data: Uint8Array): void {
         if (this.stopped) {
             throw new Err.SendFailed('ManagedConnection is stopped')
         }
-        if (this.closing) {
-            throw new Err.SendFailed('ManagedConnection is closing')
-        }
-        this.lastUsedTimestamp = Date.now()
-
-        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<OutputBufferEvents>
-
-            try {
-                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`, {
-                    peerDescriptor: this.remotePeerDescriptor,
-                    type: this.connectionType,
-                    lifetime: Date.now() - this.created
-                })
-                await this.close(false)
-                throw new Err.SendFailed('Sending buffer timed out')
-            }
-
-            if (result.winnerName === 'bufferSendingFailed') {
-                throw new Err.SendFailed('Sending buffer failed')
-            }
-            // buffer was sent successfully, return normally
-        }
-    }
-
-    public sendNoWait(data: Uint8Array): void {
         this.lastUsedTimestamp = Date.now()
-        if (this.implementation) {
-            this.implementation.send(data)
-        } else {
-            logger.trace('adding data to outputBuffer')
-            this.outputBuffer.push(data)
-        }
+        this.connection.send(data)
     }
 
-    public reportBufferSentByOtherConnection(): void {
-        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' reportBufferSentByOtherConnection')
-        if (this.handshaker) {
-            this.handshaker.removeAllListeners()
-        }
-        logger.trace('bufferSentByOtherConnection reported')
-        this.bufferSentbyOtherConnection = true
-        this.outputBufferEmitter.emit('bufferSent')
-    }
-
-    public acceptHandshake(): void {
-        // This happens when connectionRequest has been made and answered
-        if (this.implementation) {
-            if (!this.handshaker) {
-                this.handshaker = new Handshaker(this.localPeerDescriptor, this.implementation)
-            }
-
-            this.handshaker.sendHandshakeResponse()
-
-        } else {  // This happens to when there is a regular incoming connection
-            this.handshaker!.sendHandshakeResponse()
-            this.attachImplementation(this.incomingConnection!)
-        }
-
-        this.onHandshakeCompleted(this.remotePeerDescriptor!)
-    }
-
-    public rejectHandshake(error: HandshakeError): void {
-        this.handshaker!.sendHandshakeResponse(error)
-        this.destroy()
-    }
-
-    public async close(gracefulLeave: boolean): Promise<void> {
-        if (this.closing) {
+    async close(gracefulLeave: boolean): Promise<void> {
+        if (this.stopped) {
             return
         }
-        if (this.replacedByOtherConnection) {
-            logger.trace('close() called on replaced connection')
-        }
-        this.closing = true
-        
-        this.outputBufferEmitter.emit('bufferSendingFailed')
-       
-        if (this.implementation) {
-            await this.implementation?.close(gracefulLeave)
-        } else if (this.outgoingConnection) {
-            await this.outgoingConnection?.close(gracefulLeave)
-        } else if (this.incomingConnection) {
-            await this.incomingConnection?.close(gracefulLeave)
-        } else {
-            this.emit('disconnected', gracefulLeave)
-        }
+        await this.connection.close(gracefulLeave)       
+        this.removeAllListeners()
     }
 
-    public destroy(): void {
-        this.closing = true
-        if (!this.stopped) {
-            this.stopped = true
-
-            this.removeAllListeners()
-            if (this.implementation) {
-                this.implementation?.destroy()
-            } else if (this.outgoingConnection) {
-                this.outgoingConnection?.destroy()
-            } else if (this.incomingConnection) {
-                this.incomingConnection?.destroy()
-            }
-        }
+    getNodeId(): DhtAddress {
+        return getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
     }
 
-    isHandshakeCompleted(): boolean {
-        return this.handshakeCompleted
+    getLastUsedTimestamp(): number {
+        return this.lastUsedTimestamp
     }
 
-    stealOutputBuffer(): Uint8Array[] {
-        const ret = this.outputBuffer
-        this.outputBuffer = []
-        return ret
+    getPeerDescriptor(): PeerDescriptor | undefined {
+        return this.remotePeerDescriptor
     }
+
 }

package/src/connection/OutputBuffer.ts

@@ -0,0 +1,28 @@
+import { Defer } from '@streamr/utils'
+import { SendFailed } from '../helpers/errors'
+
+export class OutputBuffer {
+
+    private readonly buffer: Uint8Array[] = []
+    private readonly deferredPromise: Defer<void> = new Defer<void>()
+
+    push(message: Uint8Array): Defer<void> {
+        this.buffer.push(message)
+        return this.deferredPromise
+    }
+
+    getBuffer(): Uint8Array[] {
+        return this.buffer
+    }
+
+    resolve(): void {
+        this.buffer.length = 0
+        this.deferredPromise.resolve()
+    }
+
+    reject(): void {
+        this.buffer.length = 0
+        this.deferredPromise.reject(new SendFailed('Could not send buffered messages'))
+    }
+
+}

package/src/connection/PendingConnection.ts

@@ -0,0 +1,68 @@
+import EventEmitter from 'eventemitter3'
+import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { Logger, setAbortableTimeout } from '@streamr/utils'
+import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
+import { IConnection } from './IConnection'
+
+export interface PendingConnectionEvents {
+    connected: (peerDescriptor: PeerDescriptor, connection: IConnection) => void
+    disconnected: (gracefulLeave: boolean) => void
+}
+
+const logger = new Logger(module)
+
+// PendingConnection is used as a reference to a connection that should be opened and handshaked to a given PeerDescriptor
+// It does not hold a connection internally. The public method onHandshakedCompleted should be called once a connection for the 
+// remotePeerDescriptor is opened and handshaked successfully.
+// PendingConnections are created by the Connectors.
+export class PendingConnection extends EventEmitter<PendingConnectionEvents> {
+
+    private readonly connectingAbortController: AbortController = new AbortController()
+    private remotePeerDescriptor: PeerDescriptor
+    private replacedAsDuplicate: boolean = false
+    private stopped: boolean = false
+
+    constructor(remotePeerDescriptor: PeerDescriptor, timeout = 15 * 1000) {
+        super()
+        this.remotePeerDescriptor = remotePeerDescriptor
+        setAbortableTimeout(() => {
+            this.close(false)
+        }, timeout, this.connectingAbortController.signal)
+    }
+
+    replaceAsDuplicate(): void {
+        logger.trace(getNodeIdOrUnknownFromPeerDescriptor(this.remotePeerDescriptor) + ' replaceAsDuplicate')
+        this.replacedAsDuplicate = true
+    }
+
+    onHandshakeCompleted(connection: IConnection): void {
+        if (!this.replacedAsDuplicate) {
+            this.emit('connected', this.remotePeerDescriptor, connection)
+        }
+    }
+
+    close(graceful: boolean): void {
+        if (this.stopped) {
+            return
+        }
+        this.stopped = true
+        this.connectingAbortController.abort()
+        if (!this.replacedAsDuplicate) {
+            this.emit('disconnected', graceful)
+        }
+    }
+
+    destroy(): void {
+        if (this.stopped) {
+            return
+        }
+        this.stopped = true
+        this.connectingAbortController.abort()
+        this.removeAllListeners()
+    }
+
+    getPeerDescriptor(): PeerDescriptor {
+        return this.remotePeerDescriptor
+    }
+
+}

package/src/connection/connectivityChecker.ts

@@ -7,12 +7,12 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ConnectionEvents, IConnection } from './IConnection'
 import { WebsocketClientConnection } from './websocket/NodeWebsocketClientConnection'
-import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector'
+import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketClientConnector'
 import { isMaybeSupportedVersion } from '../helpers/version'
 
 const logger = new Logger(module)
 
-// TODO use config option or named constant?
+// TODO use options option or named constant?
 export const connectAsync = async ({ url, allowSelfSignedCertificate, timeoutMs = 1000 }:
     { url: string, allowSelfSignedCertificate: boolean, timeoutMs?: number }
 ): Promise<IConnection> => {

package/src/connection/connectivityRequestHandler.ts

@@ -9,7 +9,7 @@ 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 { connectivityMethodToWebsocketUrl } from './websocket/WebsocketClientConnector'
 import { LOCAL_PROTOCOL_VERSION } from '../helpers/version'
 import { GeoIpLocator } from '@streamr/geoip-location'
 

package/src/connection/simulator/Simulator.ts

@@ -1,7 +1,5 @@
 /* eslint-disable @typescript-eslint/parameter-properties */
-import EventEmitter from 'eventemitter3'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { ConnectionSourceEvents } from '../IConnectionSource'
 import { SimulatorConnector } from './SimulatorConnector'
 import { SimulatorConnection } from './SimulatorConnection'
 import { ConnectionID } from '../IConnection'
@@ -89,7 +87,7 @@ class SendOperation extends SimulatorOperation {
 class CloseOperation extends SimulatorOperation {
 }
 
-export class Simulator extends EventEmitter<ConnectionSourceEvents> {
+export class Simulator {
     private stopped = false
     private connectors: Map<DhtAddress, SimulatorConnector> = new Map()
     private latencyTable?: Array<Array<number>>
@@ -112,8 +110,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     private simulatorTimeout?: NodeJS.Timeout
 
     constructor(latencyType: LatencyType = LatencyType.NONE, fixedLatency?: number) {
-        super()
-
         this.latencyType = latencyType
         this.fixedLatency = fixedLatency
 

package/src/connection/simulator/SimulatorConnection.ts

@@ -95,8 +95,7 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingData(data: Uint8Array): void {
         if (!this.stopped) {
-            logger.trace('handleIncomingData()')
-            logger.trace(protoToString(Message.fromBinary(data), Message))
+            logger.trace('handleIncomingData() ' + protoToString(Message.fromBinary(data), Message))
             this.emit('data', data)
         } else {
             logger.trace('tried to call handleIncomingData() a stopped connection')

package/src/connection/simulator/SimulatorConnector.ts

@@ -5,32 +5,33 @@ import {
     PeerDescriptor,
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
-import { ManagedConnection } from '../ManagedConnection'
 import { Simulator } from './Simulator'
 import { SimulatorConnection } from './SimulatorConnection'
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { acceptHandshake, createIncomingHandshaker, createOutgoingHandshaker, rejectHandshake } from '../Handshaker'
+import { PendingConnection } from '../PendingConnection'
 
 const logger = new Logger(module)
 
 export class SimulatorConnector {
 
-    private connectingConnections: Map<DhtAddress, ManagedConnection> = new Map()
+    private connectingConnections: Map<DhtAddress, PendingConnection> = new Map()
     private stopped = false
     private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
-    private onNewConnection: (connection: ManagedConnection) => boolean
+    private onNewConnection: (connection: PendingConnection) => boolean
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
-        onNewConnection: (connection: ManagedConnection) => boolean
+        onNewConnection: (connection: PendingConnection) => boolean,
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.simulator = simulator
         this.onNewConnection = onNewConnection
     }
 
-    public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+    public connect(targetPeerDescriptor: PeerDescriptor): PendingConnection {
         logger.trace('connect() ' + getNodeIdFromPeerDescriptor(targetPeerDescriptor))
         const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(nodeId)
@@ -40,20 +41,21 @@ export class SimulatorConnector {
 
         const connection = new SimulatorConnection(this.localPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
-        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
-
-        this.connectingConnections.set(nodeId, managedConnection)
-        connection.once('disconnected', () => {
-            this.connectingConnections.delete(nodeId)
-        })
-        connection.once('connected', () => {
+        const pendingConnection = new PendingConnection(targetPeerDescriptor)
+        createOutgoingHandshaker(this.localPeerDescriptor, pendingConnection, connection, targetPeerDescriptor)
+        this.connectingConnections.set(nodeId, pendingConnection)
+        const delFunc = () => {
             this.connectingConnections.delete(nodeId)
-        })
-
+            connection.off('disconnected', delFunc)
+            pendingConnection.off('connected', delFunc)
+            pendingConnection.off('disconnected', delFunc)
+        }
+        connection.once('disconnected', delFunc)
+        pendingConnection.once('connected', delFunc)
+        pendingConnection.once('disconnected', delFunc)
+        
         connection.connect()
-
-        return managedConnection
+        return pendingConnection
     }
 
     public getPeerDescriptor(): PeerDescriptor {
@@ -61,26 +63,27 @@ export class SimulatorConnector {
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        const localNodeId = getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor)
-        logger.trace(localNodeId + ' incoming connection, stopped: ' + this.stopped)
+        // connection is incoming, so remotePeerDescriptor is localPeerDescriptor
+        const remotePeerDescriptor = sourceConnection.localPeerDescriptor
+        const remoteNodeId = getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor)
+        logger.trace(remoteNodeId + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
-        const connection = new SimulatorConnection(this.localPeerDescriptor,
-            sourceConnection.localPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
-
-        const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_SERVER, undefined, connection)
-
+        const connection = new SimulatorConnection(this.localPeerDescriptor, remotePeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
+        
+        const pendingConnection = new PendingConnection(remotePeerDescriptor)
+        const handshaker = createIncomingHandshaker(this.localPeerDescriptor, pendingConnection, connection)
         logger.trace('connected')
 
-        managedConnection.once('handshakeRequest', () => {
-            logger.trace(localNodeId + ' incoming handshake request')
+        handshaker.once('handshakeRequest', () => {
+            logger.trace(remoteNodeId + ' incoming handshake request')
 
-            if (this.onNewConnection(managedConnection)) {
-                logger.trace(localNodeId + ' calling acceptHandshake')
-                managedConnection.acceptHandshake()
+            if (this.onNewConnection(pendingConnection)) {
+                logger.trace(remoteNodeId + ' calling acceptHandshake')
+                acceptHandshake(handshaker, pendingConnection, connection)
             } else {
-                managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)
+                rejectHandshake(pendingConnection, connection, handshaker, HandshakeError.DUPLICATE_CONNECTION)
             }
         })
 
@@ -90,8 +93,6 @@ export class SimulatorConnector {
     public async stop(): Promise<void> {
         this.stopped = true
         const conns = Array.from(this.connectingConnections.values())
-        await Promise.allSettled(conns.map((conn) =>
-            conn.close(false)
-        ))
+        await Promise.allSettled(conns.map(async (conn) => conn.close(false)))
     }
 }