@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-rc.1

package/src/connection/simulator/SimulatorConnection.ts

@@ -4,7 +4,7 @@ import { Message, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Connection } from '../Connection'
 import { Logger } from '@streamr/utils'
 import { protoToString } from '../../helpers/protoToString'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -45,38 +45,34 @@ export class SimulatorConnection extends Connection implements IConnection {
             this.simulator.send(this, data)
 
         } else {
-            logger.error(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
-                'tried to send() on a stopped connection')
+            const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+            const targetNodeId = getNodeIdFromPeerDescriptor(this.targetPeerDescriptor)
+            logger.error(localNodeId + ', ' + targetNodeId + 'tried to send() on a stopped connection')
         }
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
-        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
-            + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' close()')
+        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+        const targetNodeId = getNodeIdFromPeerDescriptor(this.targetPeerDescriptor)
 
+        logger.trace(localNodeId + ', ' + targetNodeId + ' close()')
         if (!this.stopped) {
-            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', '
-                + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' close() not stopped')
+            logger.trace(localNodeId + ', ' + targetNodeId + ' close() not stopped')
             this.stopped = true
 
             try {
-                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
-                    ' close() calling simulator.disconnect()')
+                logger.trace(localNodeId + ', ' + targetNodeId + ' close() calling simulator.disconnect()')
                 this.simulator.close(this)
-                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
-                    ' close() simulator.disconnect returned')
+                logger.trace(localNodeId + ', ' + targetNodeId + ' close() simulator.disconnect returned')
             } catch (e) {
-                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
-                    'close aborted' + e)
+                logger.trace(localNodeId + ', ' + targetNodeId + 'close aborted' + e)
             } finally {
-                logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
-                    ' calling this.doDisconnect')
+                logger.trace(localNodeId + ', ' + targetNodeId + ' calling this.doDisconnect')
                 this.doDisconnect(gracefulLeave)
             }
 
         } else {
-            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', ' + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) +
-                ' close() tried to close a stopped connection')
+            logger.trace(localNodeId + ', ' + targetNodeId + ' close() tried to close a stopped connection')
         }
     }
 
@@ -85,7 +81,7 @@ export class SimulatorConnection extends Connection implements IConnection {
             logger.trace('connect() called')
 
             this.simulator.connect(this, this.targetPeerDescriptor, (error?: string) => {
-                if (error) {
+                if (error !== undefined) {
                     logger.trace(error)
                     this.doDisconnect(false)
                 } else {
@@ -109,7 +105,8 @@ export class SimulatorConnection extends Connection implements IConnection {
 
     public handleIncomingDisconnection(): void {
         if (!this.stopped) {
-            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' handleIncomingDisconnection()')
+            const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+            logger.trace(localNodeId + ' handleIncomingDisconnection()')
             this.stopped = true
             this.doDisconnect(false)
         } else {
@@ -118,23 +115,24 @@ export class SimulatorConnection extends Connection implements IConnection {
     }
 
     public destroy(): void {
+        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
         if (!this.stopped) {
-            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' destroy()')
+            logger.trace(localNodeId + ' destroy()')
             this.removeAllListeners()
             this.close(false).catch((_e) => { })
         } else {
-            logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' tried to call destroy() a stopped connection')
+            logger.trace(localNodeId + ' tried to call destroy() a stopped connection')
         }
     }
 
     private doDisconnect(gracefulLeave: boolean) {
-        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ' doDisconnect()')
+        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor)
+        const targetNodeId = getNodeIdFromPeerDescriptor(this.targetPeerDescriptor)
+        logger.trace(localNodeId + ' doDisconnect()')
         this.stopped = true
 
-        logger.trace(getNodeIdFromPeerDescriptor(this.localPeerDescriptor) + ', '
-            + getNodeIdFromPeerDescriptor(this.targetPeerDescriptor) + ' doDisconnect emitting')
+        logger.trace(localNodeId + ', ' + targetNodeId + ' doDisconnect emitting')
 
         this.emit('disconnected', gracefulLeave)
-
     }
 }

package/src/connection/simulator/SimulatorConnector.ts

@@ -6,16 +6,15 @@ 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 { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
 export class SimulatorConnector {
 
-    private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private connectingConnections: Map<DhtAddress, ManagedConnection> = new Map()
     private stopped = false
     private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
@@ -33,8 +32,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 +43,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()
@@ -62,7 +61,8 @@ export class SimulatorConnector {
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
+        const localNodeId = getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor)
+        logger.trace(localNodeId + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
@@ -74,10 +74,10 @@ export class SimulatorConnector {
         logger.trace('connected')
 
         managedConnection.once('handshakeRequest', () => {
-            logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming handshake request')
+            logger.trace(localNodeId + ' incoming handshake request')
 
             if (this.onNewConnection(managedConnection)) {
-                logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' calling acceptHandshake')
+                logger.trace(localNodeId + ' calling acceptHandshake')
                 managedConnection.acceptHandshake()
             } else {
                 managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)

package/src/connection/webrtc/BrowserWebrtcConnection.ts

@@ -3,6 +3,7 @@ import { WebrtcConnectionEvents, IWebrtcConnection, RtcDescription } from './IWe
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { Logger } from '@streamr/utils'
 import { IceServer } from './WebrtcConnector'
+import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
 
@@ -22,12 +23,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
@@ -37,7 +35,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
 
     constructor(params: Params) {
         super()
-        this.connectionId = new ConnectionID()
+        this.connectionId = createRandomConnectionId()
         this.iceServers = params.iceServers ?? []
     }
 
@@ -51,7 +49,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         this.peerConnection = new RTCPeerConnection({ iceServers: urls })
 
         this.peerConnection.onicecandidate = (event) => {
-            if (event.candidate && event.candidate.sdpMid) {
+            if ((event.candidate !== null) && (event.candidate.sdpMid !== null)) {
                 this.emit('localCandidate', event.candidate.candidate, event.candidate.sdpMid)
             }
         }
@@ -63,14 +61,14 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         if (isOffering) {
             this.peerConnection.onnegotiationneeded = async () => {
                 try {
-                    if (this.peerConnection) {
+                    if (this.peerConnection !== undefined) {
                         this.makingOffer = true
                         try {
                             await this.peerConnection.setLocalDescription()
                         } catch (err) {
                             logger.warn('error', { err })
                         }
-                        if (this.peerConnection.localDescription) {
+                        if (this.peerConnection.localDescription !== null) {
                             this.emit('localDescription', this.peerConnection.localDescription?.sdp, this.peerConnection.localDescription?.type)
                         }
                     }
@@ -86,14 +84,12 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         } else {
             this.peerConnection.ondatachannel = (event) => {
                 this.setupDataChannel(event.channel)
-                logger.trace('connection.onDataChannel')
-                this.openDataChannel(event.channel)
             }
         }
     }
 
     public async setRemoteDescription(description: string, type: string): Promise<void> {
-        const offerCollision = (type.toLowerCase() === RtcDescription.OFFER) && (this.makingOffer || !this.peerConnection ||
+        const offerCollision = (type.toLowerCase() === RtcDescription.OFFER) && (this.makingOffer || (this.peerConnection === undefined) ||
             this.peerConnection.signalingState != 'stable')
 
         const ignoreOffer = this.isOffering && offerCollision
@@ -106,13 +102,13 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             logger.warn('error', { err })
         }
 
-        if (type.toLowerCase() === RtcDescription.OFFER && this.peerConnection) {
+        if ((type.toLowerCase() === RtcDescription.OFFER) && (this.peerConnection !== undefined)) {
             try {
                 await this.peerConnection.setLocalDescription()
             } catch (err) {
                 logger.warn('error', { err })
             }
-            if (this.peerConnection.localDescription) {
+            if (this.peerConnection.localDescription !== null) {
                 this.emit('localDescription', this.peerConnection.localDescription.sdp, this.peerConnection.localDescription.type)
             }
         }
@@ -148,7 +144,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             
             this.removeAllListeners()
 
-            if (this.dataChannel) {
+            if (this.dataChannel !== undefined) {
                 try {
                     this.dataChannel.close()
                 } catch (e) {
@@ -158,7 +154,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
 
             this.dataChannel = undefined
 
-            if (this.peerConnection) {
+            if (this.peerConnection !== undefined) {
                 try {
                     this.peerConnection.close()
                 } catch (e) {
@@ -184,9 +180,10 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
     }
 
     private setupDataChannel(dataChannel: RTCDataChannel): void {
+        this.dataChannel = dataChannel
         dataChannel.onopen = () => {
             logger.trace('dc.onOpen')
-            this.openDataChannel(dataChannel)
+            this.onDataChannelOpen()
         }
 
         dataChannel.onclose = () => {
@@ -198,10 +195,6 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             logger.warn(`dc.onError: ${err}`)
         }
 
-        dataChannel.onbufferedamountlow = () => {
-            //this.emitLowBackpressure()
-        }
-
         dataChannel.onmessage = (msg) => {
             logger.trace('dc.onmessage')
             this.emit('data', new Uint8Array(msg.data))
@@ -209,7 +202,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
     }
 
     private stopListening() {
-        if (this.dataChannel) {
+        if (this.dataChannel !== undefined) {
             this.dataChannel.onopen = null
             this.dataChannel.onclose = null
             this.dataChannel.onerror = null
@@ -217,7 +210,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
             this.dataChannel.onmessage = null
         }
 
-        if (this.peerConnection) {
+        if (this.peerConnection !== undefined) {
             this.peerConnection.onicecandidate = null
             this.peerConnection.onicegatheringstatechange = null
             this.peerConnection.onnegotiationneeded = null
@@ -225,13 +218,12 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrt
         }
     }
 
-    private openDataChannel(dataChannel: RTCDataChannel): void {
-        this.dataChannel = dataChannel
+    private onDataChannelOpen(): void {
         this.lastState = 'connected'
         this.emit('connected')
     }
 
-    public setConnectionId(connectionID: string): void {
-        this.connectionId = new ConnectionID(connectionID)
+    public setConnectionId(connectionId: ConnectionID): void {
+        this.connectionId = connectionId
     }
 }

package/src/connection/webrtc/NodeWebrtcConnection.ts

@@ -5,10 +5,11 @@ 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 { iceServerAsString } from './iceServerAsString'
 import { IceServer } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
 
@@ -25,7 +26,7 @@ export interface Params {
     bufferThresholdLow?: number
     connectingTimeout?: number
     maxMessageSize?: number
-    iceServers?: IceServer[]
+    iceServers?: IceServer[]  // TODO make this parameter required (empty array is a good fallback which can be set by the caller if needed)
     portRange?: PortRange
 }
 
@@ -55,7 +56,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)
@@ -68,7 +68,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
 
     constructor(params: Params) {
         super()
-        this.connectionId = new ConnectionID()
+        this.connectionId = createRandomConnectionId()
         this.iceServers = params.iceServers ?? []
         // eslint-disable-next-line no-underscore-dangle
         this._bufferThresholdHigh = params.bufferThresholdHigh ?? 2 ** 17
@@ -80,9 +80,9 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     }
 
     public start(isOffering: boolean): void {
-        const peerIdKey = keyFromPeerDescriptor(this.remotePeerDescriptor)
-        logger.trace(`Starting new connection for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`, { isOffering })
-        this.connection = new PeerConnection(peerIdKey, {
+        const nodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+        logger.trace(`Starting new connection for peer ${nodeId}`, { isOffering })
+        this.connection = new PeerConnection(nodeId, {
             iceServers: this.iceServers.map(iceServerAsString),
             maxMessageSize: this.maxMessageSize,
             portRangeBegin: this.portRange?.min,
@@ -107,18 +107,19 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             const dataChannel = this.connection.createDataChannel('streamrDataChannel')
             this.setupDataChannel(dataChannel)
         } else {
-            this.connection.onDataChannel((dataChannel) => this.onDataChannel(dataChannel))
+            this.connection.onDataChannel((dataChannel) => this.setupDataChannel(dataChannel))
         }
     }
 
     public async setRemoteDescription(description: string, type: string): Promise<void> {
         if (this.connection) {
+            const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
             try {
-                logger.trace(`Setting remote descriptor for peer: ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.trace(`Setting remote descriptor for peer: ${remoteNodeId}`)
                 this.connection.setRemoteDescription(description, type as DescriptionType)
                 this.remoteDescriptionSet = true
             } catch (err) {
-                logger.debug(`Failed to set remote descriptor for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.debug(`Failed to set remote descriptor for peer ${remoteNodeId}`)
             }
         } else {
             this.doClose(false, `Tried to set description for non-existent connection`)
@@ -128,11 +129,12 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
     public addRemoteCandidate(candidate: string, mid: string): void {
         if (this.connection) {
             if (this.remoteDescriptionSet) {
+                const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
                 try {
-                    logger.trace(`Setting remote candidate for peer: ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    logger.trace(`Setting remote candidate for peer: ${remoteNodeId}`)
                     this.connection.addRemoteCandidate(candidate, mid)
                 } catch (err) {
-                    logger.debug(`Failed to set remote candidate for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    logger.debug(`Failed to set remote candidate for peer ${remoteNodeId}`)
                 }
             } else {
                 // TODO: should queue candidates until remote description is set?
@@ -148,7 +150,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
             try {
                 this.dataChannel!.sendMessageBinary(data as Buffer)
             } catch (err) {
-                logger.debug('Failed to send binary message to ' + getNodeIdFromPeerDescriptor(this.remotePeerDescriptor) + err)
+                const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+                logger.debug('Failed to send binary message to ' + remoteNodeId + err)
             }
         }
     }
@@ -159,10 +162,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
 
     private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
-            logger.trace(
-                `Closing Node WebRTC Connection to ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`
-                + `${reason ? `, reason: ${reason}` : ''}`
-            )
+            const remoteNodeId = getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)
+            logger.trace(`Closing Node WebRTC Connection to ${remoteNodeId}` + `${(reason !== undefined) ? `, reason: ${reason}` : ''}`)
 
             this.closed = true
             
@@ -189,6 +190,8 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
                     logger.trace('conn.close() errored: %s', e)
                 }
             }
+            this.connection = undefined
+            this.dataChannel = undefined
         }
     }
 
@@ -197,16 +200,12 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         this.doClose(false)
     }
 
-    private onDataChannel(dataChannel: DataChannel): void {
-        this.openDataChannel(dataChannel)
-        this.setupDataChannel(dataChannel)
-    }
-
     private setupDataChannel(dataChannel: DataChannel): void {
+        this.dataChannel = dataChannel
         dataChannel.setBufferedAmountLowThreshold(this.bufferThresholdLow)
         dataChannel.onOpen(() => {
             logger.trace(`dc.onOpened`)
-            this.openDataChannel(dataChannel)
+            this.onDataChannelOpen()
         })
 
         dataChannel.onClosed(() => {
@@ -226,11 +225,10 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         })
     }
 
-    private openDataChannel(dataChannel: DataChannel): void {
+    private onDataChannelOpen(): void {
         if (this.connectingTimeoutRef) {
             clearTimeout(this.connectingTimeoutRef)
         }
-        this.dataChannel = dataChannel
         logger.trace(`DataChannel opened for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }
@@ -256,7 +254,7 @@ export class NodeWebrtcConnection extends EventEmitter<Events> implements IConne
         return !this.closed && this.lastState === 'connected' && !!this.dataChannel
     }
 
-    public setConnectionId(connectionID: string): void {
-        this.connectionId = new ConnectionID(connectionID)
+    public setConnectionId(connectionId: ConnectionID): void {
+        this.connectionId = connectionId
     }
 }

package/src/connection/webrtc/WebrtcConnector.ts

@@ -9,21 +9,15 @@ 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 { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { getOfferer } from '../../helpers/offering'
 
 const logger = new Logger(module)
 
@@ -60,10 +54,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<DhtAddress, ManagedWebrtcConnection> = new Map()
     private localPeerDescriptor?: PeerDescriptor
     private stopped = false
-    private iceServers: IceServer[]
     private config: WebrtcConnectorConfig
 
     constructor(
@@ -71,9 +64,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)
     }
@@ -83,6 +75,7 @@ export class WebrtcConnector {
         onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         const localRpc = new WebrtcConnectorRpcLocal({
+            createConnection: (targetPeerDescriptor: PeerDescriptor) => this.createConnection(targetPeerDescriptor),
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
             onNewConnection,
             ongoingConnectAttempts: this.ongoingConnectAttempts,
@@ -135,22 +128,17 @@ 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,
-            bufferThresholdLow: this.config.bufferThresholdLow,
-            bufferThresholdHigh: this.config.bufferThresholdHigh,
-            connectingTimeout: this.config.connectionTimeout,
-            portRange: this.config.portRange
-        })
+        const connection = this.createConnection(targetPeerDescriptor)
 
-        const offering = this.isOffering(targetPeerDescriptor)
+        const localNodeId = getNodeIdFromPeerDescriptor(this.localPeerDescriptor!)
+        const targetNodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+        const offering = (getOfferer(localNodeId, targetNodeId) === 'local')
         let managedConnection: ManagedWebrtcConnection
 
         if (offering) {
@@ -161,10 +149,10 @@ export class WebrtcConnector {
 
         managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
-        this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+        this.ongoingConnectAttempts.set(targetNodeId, managedConnection)
 
         const delFunc = () => {
-            this.ongoingConnectAttempts.delete(peerKey)
+            this.ongoingConnectAttempts.delete(nodeId)
             connection.off('disconnected', delFunc)
             managedConnection.off('handshakeCompleted', delFunc)
         }
@@ -174,24 +162,25 @@ export class WebrtcConnector {
         const remoteConnector = new WebrtcConnectorRpcRemote(
             this.localPeerDescriptor!,
             targetPeerDescriptor,
-            toProtoRpcClient(new WebrtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+            this.rpcCommunicator,
+            WebrtcConnectorRpcClient
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {
-            if (this.config.externalIp) {
+            if (this.config.externalIp !== undefined) {
                 candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
                 logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
             }
-            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId.toString())
+            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId)
         })
 
         if (offering) {
             connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcOffer(description, connection.connectionId.toString())
+                remoteConnector.sendRtcOffer(description, connection.connectionId)
             })
         } else {
             connection.once('localDescription', (description: string) => {
-                remoteConnector.sendRtcAnswer(description, connection.connectionId.toString())
+                remoteConnector.sendRtcAnswer(description, connection.connectionId)
             })
         }
 
@@ -204,6 +193,18 @@ export class WebrtcConnector {
         return managedConnection
     }
 
+    private createConnection(targetPeerDescriptor: PeerDescriptor): NodeWebrtcConnection {
+        return new NodeWebrtcConnection({
+            remotePeerDescriptor: targetPeerDescriptor,
+            iceServers: this.config.iceServers,
+            bufferThresholdLow: this.config.bufferThresholdLow,
+            bufferThresholdHigh: this.config.bufferThresholdHigh,
+            connectingTimeout: this.config.connectionTimeout,
+            portRange: this.config.portRange
+            // TODO should we pass maxMessageSize?
+        })
+    }
+
     setLocalPeerDescriptor(peerDescriptor: PeerDescriptor): void {
         this.localPeerDescriptor = peerDescriptor
     }
@@ -217,10 +218,4 @@ export class WebrtcConnector {
 
         this.rpcCommunicator.destroy()
     }
-
-    public isOffering(targetPeerDescriptor: PeerDescriptor): boolean {
-        const myId = peerIdFromPeerDescriptor(this.localPeerDescriptor!)
-        const theirId = peerIdFromPeerDescriptor(targetPeerDescriptor)
-        return myId.hasSmallerHashThan(theirId)
-    }
 }