@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.0

package/src/connection/ConnectorFacade.ts

@@ -16,6 +16,7 @@ export interface ConnectorFacade {
     getLocalPeerDescriptor: () => PeerDescriptor | undefined
     start: (
         onNewConnection: (connection: ManagedConnection) => boolean,
+        hasConnection: (peerDescriptor: PeerDescriptor) => boolean,
         autoCertifierTransport: ITransport
     ) => Promise<void>
     stop: () => Promise<void>
@@ -58,6 +59,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
 
     async start(
         onNewConnection: (connection: ManagedConnection) => boolean,
+        hasConnection: (peerDescriptor: PeerDescriptor) => boolean,
         autoCertifierTransport: ITransport
     ): Promise<void> {
         logger.trace(`Creating WebsocketConnectorRpcLocal`)
@@ -65,6 +67,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             transport: this.config.transport,
             // TODO should we use canConnect also for WebrtcConnector? (NET-1142)
             onNewConnection,
+            hasConnection,
             portRange: this.config.websocketPortRange,
             host: this.config.websocketHost,
             entrypoints: this.config.entryPoints,

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 { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
+import { NodeID } from '../helpers/nodeId'
 
 export interface ManagedConnectionEvents {
     managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void
     handshakeRequest: (source: PeerDescriptor, 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,29 +27,22 @@ 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()
 
@@ -166,8 +152,8 @@ export class ManagedConnection extends EventEmitter<Events> {
         return this
     }
 
-    public get peerIdKey(): PeerIDKey {
-        return keyFromPeerDescriptor(this.remotePeerDescriptor!)
+    public getNodeId(): NodeID {
+        return getNodeIdFromPeerDescriptor(this.remotePeerDescriptor!)
     }
 
     public getLastUsed(): number {
@@ -233,7 +219,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')
         }
@@ -242,18 +228,18 @@ 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`, {
                     peerDescriptor: this.remotePeerDescriptor,
@@ -289,7 +275,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         logger.trace('bufferSentByOtherConnection reported')
         this.bufferSentbyOtherConnection = true
         this.outputBufferEmitter.emit('bufferSent')
-        this.emit('bufferSentByOtherConnection')
     }
 
     public acceptHandshake(): void {
@@ -324,7 +309,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.closing = true
         
         this.outputBufferEmitter.emit('bufferSendingFailed')
-        this.emit('closing')
        
         if (this.implementation) {
             await this.implementation?.close(gracefulLeave)
@@ -339,8 +323,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

@@ -11,6 +11,7 @@ import { connectivityMethodToWebsocketUrl } from './websocket/WebsocketConnector
 
 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> => {

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,10 @@ import { SimulatorConnection } from './SimulatorConnection'
 import { ConnectionID } from '../IConnection'
 import { Logger } from '@streamr/utils'
 import { getRegionDelayMatrix } from './pings'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } 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 { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -102,7 +92,7 @@ class CloseOperation extends SimulatorOperation {
 
 export class Simulator extends EventEmitter<ConnectionSourceEvents> {
     private stopped = false
-    private connectors: Map<PeerIDKey, SimulatorConnector> = new Map()
+    private connectors: Map<NodeID, SimulatorConnector> = new Map()
     private latencyTable?: Array<Array<number>>
     private associations: Map<ConnectionID, Association> = new Map()
 
@@ -121,22 +111,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()
@@ -214,11 +188,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,11 +285,6 @@ export class Simulator extends EventEmitter<ConnectionSourceEvents> {
         const timeDifference = firstOperationTime - currentTime
 
         this.simulatorTimeout = setTimeout(this.executeQueuedOperations, timeDifference)
-       
-        if (Simulator.clock) {
-            // TODO should we have some handling for this floating promise?
-            Simulator.clock.runAllAsync()
-        }
     }
 
     private scheduleOperation(operation: SimulatorOperation) {

package/src/connection/simulator/SimulatorConnector.ts

@@ -6,16 +6,16 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
 import { ManagedConnection } from '../ManagedConnection'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { Simulator } from './Simulator'
 import { SimulatorConnection } from './SimulatorConnection'
-import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
 export class SimulatorConnector {
 
-    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private connectingConnections: Map<NodeID, ManagedConnection> = new Map()
     private stopped = false
     private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
@@ -33,8 +33,8 @@ export class SimulatorConnector {
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
         logger.trace('connect() ' + getNodeIdFromPeerDescriptor(targetPeerDescriptor))
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.connectingConnections.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.connectingConnections.get(nodeId)
         if (existingConnection) {
             return existingConnection
         }
@@ -44,12 +44,12 @@ export class SimulatorConnector {
         const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
-        this.connectingConnections.set(peerKey, managedConnection)
+        this.connectingConnections.set(nodeId, managedConnection)
         connection.once('disconnected', () => {
-            this.connectingConnections.delete(peerKey)
+            this.connectingConnections.delete(nodeId)
         })
         connection.once('connected', () => {
-            this.connectingConnections.delete(peerKey)
+            this.connectingConnections.delete(nodeId)
         })
 
         connection.connect()

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -22,12 +22,9 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
 
     public connectionId: ConnectionID
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
-
     // We need to keep track of connection state ourselves because
     // RTCPeerConnection.connectionState is not supported on Firefox
-
     private lastState: RTCPeerConnectionState = 'connecting'
-
     private readonly iceServers: IceServer[]
     private peerConnection?: RTCPeerConnection
     private dataChannel?: RTCDataChannel

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -5,7 +5,7 @@ import EventEmitter from 'eventemitter3'
 import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
 import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
-import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { iceServerAsString } from './iceServerAsString'
 import { IceServer } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
@@ -55,7 +55,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     private lastState: RtcPeerConnectionState = 'connecting'
     private remoteDescriptionSet = false
     private connectingTimeoutRef?: NodeJS.Timeout
-
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
     private readonly iceServers: IceServer[]
     private readonly _bufferThresholdHigh: number // TODO: buffer handling must be implemented before production use (NET-938)
@@ -80,9 +79,9 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     }
 
     public start(isOffering: boolean): void {
-        const peerIdKey = keyFromPeerDescriptor(this.remotePeerDescriptor)
+        const nodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
         logger.trace(`Starting new connection for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`, { isOffering })
-        this.connection = new PeerConnection(peerIdKey, {
+        this.connection = new PeerConnection(nodeId, {
             iceServers: this.iceServers.map(iceServerAsString),
             maxMessageSize: this.maxMessageSize,
             portRangeBegin: this.portRange?.min,

package/src/connection/webrtc/WebrtcConnector.ts

@@ -9,21 +9,19 @@ import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicat
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
 import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ManagedConnection } from '../ManagedConnection'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     areEqualPeerDescriptors,
     getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
 import { PortRange } from '../ConnectionManager'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { WebrtcConnectorRpcLocal } from './WebrtcConnectorRpcLocal'
+import { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -60,10 +58,9 @@ export class WebrtcConnector {
 
     private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly ongoingConnectAttempts: Map<PeerIDKey, ManagedWebrtcConnection> = new Map()
+    private readonly ongoingConnectAttempts: Map<NodeID, ManagedWebrtcConnection> = new Map()
     private localPeerDescriptor?: PeerDescriptor
     private stopped = false
-    private iceServers: IceServer[]
     private config: WebrtcConnectorConfig
 
     constructor(
@@ -71,9 +68,8 @@ export class WebrtcConnector {
         onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         this.config = config
-        this.iceServers = config.iceServers ?? []
         this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
-            rpcRequestTimeout: 15000
+            rpcRequestTimeout: 15000  // TODO use config option or named constant?
         })
         this.registerLocalRpcMethods(config, onNewConnection)
     }
@@ -135,15 +131,15 @@ export class WebrtcConnector {
 
         logger.trace(`Opening WebRTC connection to ${getNodeIdFromPeerDescriptor(targetPeerDescriptor)}`)
 
-        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
-        const existingConnection = this.ongoingConnectAttempts.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.ongoingConnectAttempts.get(nodeId)
         if (existingConnection) {
             return existingConnection
         }
 
         const connection = new NodeWebrtcConnection({
             remotePeerDescriptor: targetPeerDescriptor,
-            iceServers: this.iceServers,
+            iceServers: this.config.iceServers,
             bufferThresholdLow: this.config.bufferThresholdLow,
             bufferThresholdHigh: this.config.bufferThresholdHigh,
             connectingTimeout: this.config.connectionTimeout,
@@ -161,10 +157,10 @@ export class WebrtcConnector {
 
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
-        this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+        this.ongoingConnectAttempts.set(getNodeIdFromPeerDescriptor(targetPeerDescriptor), managedConnection)
 
         const delFunc = () => {
-            this.ongoingConnectAttempts.delete(peerKey)
+            this.ongoingConnectAttempts.delete(nodeId)
             connection.off('disconnected', delFunc)
             managedConnection.off('handshakeCompleted', delFunc)
         }
@@ -174,7 +170,9 @@ export class WebrtcConnector {
         const remoteConnector = new WebrtcConnectorRpcRemote(
             this.localPeerDescriptor!,
             targetPeerDescriptor,
-            toProtoRpcClient(new WebrtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+            'DUMMY',
+            this.rpcCommunicator,
+            WebrtcConnectorRpcClient
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -1,9 +1,7 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Logger } from '@streamr/utils'
 import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
-import { PeerIDKey } from '../../helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../../proto/google/protobuf/empty'
 import {
     IceCandidate,
@@ -19,6 +17,7 @@ import { ManagedConnection } from '../ManagedConnection'
 import { ManagedWebrtcConnection } from '../ManagedWebrtcConnection'
 import { NodeWebrtcConnection } from './NodeWebrtcConnection'
 import { WebrtcConnectorRpcRemote } from './WebrtcConnectorRpcRemote'
+import { NodeID } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -26,7 +25,7 @@ interface WebrtcConnectorRpcLocalConfig {
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection 
     onNewConnection: (connection: ManagedConnection) => boolean
     // TODO pass accessor methods instead of passing a mutable entity
-    ongoingConnectAttempts: Map<PeerIDKey, ManagedWebrtcConnection>
+    ongoingConnectAttempts: Map<NodeID, ManagedWebrtcConnection>
     rpcCommunicator: ListeningRpcCommunicator
     getLocalPeerDescriptor: () => PeerDescriptor
     allowPrivateAddresses: boolean
@@ -42,7 +41,7 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async requestConnection(context: ServerCallContext): Promise<Empty> {
         const targetPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (this.config.ongoingConnectAttempts.has(keyFromPeerDescriptor(targetPeerDescriptor))) {
+        if (this.config.ongoingConnectAttempts.has(getNodeIdFromPeerDescriptor(targetPeerDescriptor))) {
             return {}
         }
         const managedConnection = this.config.connect(targetPeerDescriptor)
@@ -53,20 +52,22 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
         const remotePeer = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerKey = keyFromPeerDescriptor(remotePeer)
-        let managedConnection = this.config.ongoingConnectAttempts.get(peerKey)
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeer)
+        let managedConnection = this.config.ongoingConnectAttempts.get(nodeId)
         let connection = managedConnection?.getWebrtcConnection()
 
         if (!managedConnection) {
             connection = new NodeWebrtcConnection({ remotePeerDescriptor: remotePeer })
             managedConnection = new ManagedWebrtcConnection(this.config.getLocalPeerDescriptor(), undefined, connection)
             managedConnection.setRemotePeerDescriptor(remotePeer)
-            this.config.ongoingConnectAttempts.set(peerKey, managedConnection)
+            this.config.ongoingConnectAttempts.set(nodeId, managedConnection)
             this.config.onNewConnection(managedConnection)
             const remoteConnector = new WebrtcConnectorRpcRemote(
                 this.config.getLocalPeerDescriptor(),
                 remotePeer,
-                toProtoRpcClient(new WebrtcConnectorRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                'DUMMY', 
+                this.config.rpcCommunicator,
+                WebrtcConnectorRpcClient
             )
             connection.on('localCandidate', (candidate: string, mid: string) => {
                 remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId.toString())
@@ -82,8 +83,8 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
         connection!.setRemoteDescription(request.description, 'offer')
 
         managedConnection.on('handshakeRequest', () => {
-            if (this.config.ongoingConnectAttempts.has(peerKey)) {
-                this.config.ongoingConnectAttempts.delete(peerKey)
+            if (this.config.ongoingConnectAttempts.has(nodeId)) {
+                this.config.ongoingConnectAttempts.delete(nodeId)
             }
             managedConnection!.acceptHandshake()
         })
@@ -92,8 +93,8 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.config.ongoingConnectAttempts.get(peerKey)?.getWebrtcConnection()
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.config.ongoingConnectAttempts.get(nodeId)?.getWebrtcConnection()
         if (!connection) {
             return {}
         } else if (connection.connectionId.toString() !== request.connectionId) {
@@ -106,9 +107,8 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
 
     async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
         const remotePeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
-        const connection = this.config.ongoingConnectAttempts.get(peerKey)?.getWebrtcConnection()
-
+        const nodeId = getNodeIdFromPeerDescriptor(remotePeerDescriptor)
+        const connection = this.config.ongoingConnectAttempts.get(nodeId)?.getWebrtcConnection()
         if (!connection) {
             return {}
         } else if (connection.connectionId.toString() !== request.connectionId) {

package/src/connection/webrtc/WebrtcConnectorRpcRemote.ts

@@ -1,26 +1,16 @@
+import { Logger } from '@streamr/utils'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
 import {
     IceCandidate,
-    PeerDescriptor,
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { IWebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { Logger } from '@streamr/utils'
+import { WebrtcConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 
 const logger = new Logger(module)
 
-export class WebrtcConnectorRpcRemote extends RpcRemote<IWebrtcConnectorRpcClient> {
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        remotePeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IWebrtcConnectorRpcClient>
-    ) {
-        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
-    }
+export class WebrtcConnectorRpcRemote extends RpcRemote<WebrtcConnectorRpcClient> {
 
     requestConnection(): void {
         const request: WebrtcConnectionRequest = {

package/src/connection/websocket/AutoCertifierClientFacade.ts

@@ -55,12 +55,10 @@ export class AutoCertifierClientFacade {
 
     private autoCertifierClient: IAutoCertifierClient
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly setHost: (host: string) => void
-    private readonly updateCertificate: (certificate: string, privateKey: string) => void
+    private readonly config: AutoCertifierClientFacadeConfig
 
     constructor(config: AutoCertifierClientFacadeConfig) {
-        this.setHost = config.setHost
-        this.updateCertificate = config.updateCertificate
+        this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(AUTO_CERTIFIER_SERVICE_ID, config.transport)
         this.autoCertifierClient = config.createClientFactory ? config.createClientFactory() 
             : defaultAutoCertifierClientFactory(
@@ -73,8 +71,8 @@ export class AutoCertifierClientFacade {
 
     async start(): Promise<void> {
         this.autoCertifierClient.on('updatedCertificate', (subdomain: CertifiedSubdomain) => {
-            this.setHost(subdomain.fqdn)
-            this.updateCertificate(subdomain.certificate, subdomain.privateKey)
+            this.config.setHost(subdomain.fqdn)
+            this.config.updateCertificate(subdomain.certificate, subdomain.privateKey)
             logger.trace(`Updated certificate`)
         })
         await Promise.all([

package/src/connection/websocket/ClientWebsocket.ts

@@ -15,6 +15,7 @@ export const CUSTOM_GOING_AWAY = 3001
 const BINARY_TYPE = 'arraybuffer'
 
 export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements IConnection {
+
     public readonly connectionId: ConnectionID
     private socket?: Websocket
     public connectionType = ConnectionType.WEBSOCKET_CLIENT