@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/src/connection/{Simulator → simulator}/SimulatorConnector.ts

@@ -1,6 +1,7 @@
 import { ConnectionType } from '../IConnection'
 
 import {
+    HandshakeError,
     PeerDescriptor,
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
@@ -8,7 +9,7 @@ import { ManagedConnection } from '../ManagedConnection'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { Simulator } from './Simulator'
 import { SimulatorConnection } from './SimulatorConnection'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -16,32 +17,32 @@ export class SimulatorConnector {
 
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
     private stopped = false
-    private ownPeerDescriptor: PeerDescriptor
+    private localPeerDescriptor: PeerDescriptor
     private simulator: Simulator
-    private onIncomingConnection: (connection: ManagedConnection) => boolean
+    private onNewConnection: (connection: ManagedConnection) => boolean
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
-        onIncomingConnection: (connection: ManagedConnection) => boolean
+        onNewConnection: (connection: ManagedConnection) => boolean
     ) {
-        this.ownPeerDescriptor = ownPeerDescriptor
+        this.localPeerDescriptor = localPeerDescriptor
         this.simulator = simulator
-        this.onIncomingConnection = onIncomingConnection
+        this.onNewConnection = onNewConnection
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        logger.trace('connect() ' + keyFromPeerDescriptor(targetPeerDescriptor))
+        logger.trace('connect() ' + getNodeIdFromPeerDescriptor(targetPeerDescriptor))
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(peerKey)
         if (existingConnection) {
             return existingConnection
         }
 
-        const connection = new SimulatorConnection(this.ownPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
+        const connection = new SimulatorConnection(this.localPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+        const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
         this.connectingConnections.set(peerKey, managedConnection)
         connection.once('disconnected', () => {
@@ -57,31 +58,29 @@ export class SimulatorConnector {
     }
 
     public getPeerDescriptor(): PeerDescriptor {
-        return this.ownPeerDescriptor
+        return this.localPeerDescriptor
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
+        logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
-        const connection = new SimulatorConnection(this.ownPeerDescriptor,
-            sourceConnection.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
+        const connection = new SimulatorConnection(this.localPeerDescriptor,
+            sourceConnection.localPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, undefined, connection)
+        const managedConnection = new ManagedConnection(this.localPeerDescriptor, ConnectionType.SIMULATOR_SERVER, undefined, connection)
 
         logger.trace('connected')
 
         managedConnection.once('handshakeRequest', () => {
-            logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming handshake request')
-            logger.trace('incoming handshake request')
+            logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' incoming handshake request')
 
-            if (this.onIncomingConnection(managedConnection)) {
-                logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' calling acceptHandshake')
+            if (this.onNewConnection(managedConnection)) {
+                logger.trace(getNodeIdFromPeerDescriptor(sourceConnection.localPeerDescriptor) + ' calling acceptHandshake')
                 managedConnection.acceptHandshake()
             } else {
-                managedConnection.rejectHandshake('Duplicate connection')
-                managedConnection.destroy()
+                managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)
             }
         })
 
@@ -92,7 +91,7 @@ export class SimulatorConnector {
         this.stopped = true
         const conns = Array.from(this.connectingConnections.values())
         await Promise.allSettled(conns.map((conn) =>
-            conn.close('OTHER')
+            conn.close(false)
         ))
     }
 }

package/src/connection/{Simulator → simulator}/SimulatorTransport.ts

@@ -5,9 +5,9 @@ import { Simulator } from './Simulator'
 import { SimulatorConnectorFacade } from '../ConnectorFacade'
 
 export class SimulatorTransport extends ConnectionManager {
-    constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
+    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator) {
         super({
-            createConnectorFacade: () => new SimulatorConnectorFacade(ownPeerDescriptor, simulator),
+            createConnectorFacade: () => new SimulatorConnectorFacade(localPeerDescriptor, simulator),
             metricsContext: new MetricsContext()
         })
     }

package/src/connection/{WebRTC/BrowserWebRtcConnection.ts → webrtc/BrowserWebrtcConnection.ts}

@@ -1,27 +1,26 @@
 import EventEmitter from 'eventemitter3'
-import { WebRtcConnectionEvents, IWebRtcConnection, RtcDescription } from './IWebRtcConnection'
+import { WebrtcConnectionEvents, IWebrtcConnection, RtcDescription } from './IWebrtcConnection'
 import { IConnection, ConnectionID, ConnectionEvents, ConnectionType } from '../IConnection'
 import { Logger } from '@streamr/utils'
-import { DisconnectionType } from '../../transport/ITransport'
-import { IceServer } from './WebRtcConnectorRpcLocal'
+import { IceServer } from './WebrtcConnector'
 
 const logger = new Logger(module)
 
-export const WEB_RTC_CLEANUP = new class {
+export const WEBRTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
     }
 }
 
-type Events = WebRtcConnectionEvents & ConnectionEvents
+type Events = WebrtcConnectionEvents & ConnectionEvents
 
 interface Params {
     iceServers?: IceServer[]
 }
 
-export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRtcConnection, IConnection {
+export class NodeWebrtcConnection extends EventEmitter<Events> implements IWebrtcConnection, IConnection {
 
-    public readonly connectionId: ConnectionID
+    public connectionId: ConnectionID
     public readonly connectionType: ConnectionType = ConnectionType.WEBRTC
 
     // We need to keep track of connection state ourselves because
@@ -39,7 +38,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
     constructor(params: Params) {
         super()
         this.connectionId = new ConnectionID()
-        this.iceServers = params.iceServers || []
+        this.iceServers = params.iceServers ?? []
     }
 
     public start(isOffering: boolean): void {
@@ -135,17 +134,17 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
 
     // IConnection implementation
     
-    public async close(disconnectionType: DisconnectionType, reason?: string): Promise<void> {
-        this.doClose(disconnectionType, reason)
+    public async close(gracefulLeave: boolean, reason?: string): Promise<void> {
+        this.doClose(gracefulLeave, reason)
     }
     
-    private doClose(disconnectionType: DisconnectionType, reason?: string): void {
+    private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
             this.closed = true
             this.lastState = 'closed'
 
             this.stopListening()
-            this.emit('disconnected', disconnectionType, undefined, reason)
+            this.emit('disconnected', gracefulLeave, undefined, reason)
             
             this.removeAllListeners()
 
@@ -173,7 +172,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
 
     public destroy(): void {
         this.removeAllListeners()
-        this.doClose('OTHER')
+        this.doClose(false)
     }
 
     public send(data: Uint8Array): void {
@@ -192,7 +191,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IWebRt
 
         dataChannel.onclose = () => {
             logger.trace('dc.onClosed')
-            this.doClose('OTHER')
+            this.doClose(false)
         }
 
         dataChannel.onerror = (err) => {

package/src/connection/{WebRTC/IWebRtcConnection.ts → webrtc/IWebrtcConnection.ts}

@@ -1,4 +1,4 @@
-export interface WebRtcConnectionEvents {
+export interface WebrtcConnectionEvents {
     localDescription: (description: string, type: string) => void
     localCandidate: (candidate: string, mid: string) => void
 }
@@ -8,7 +8,7 @@ export enum RtcDescription {
     ANSWER = 'answer'
 }
 
-export interface IWebRtcConnection {
+export interface IWebrtcConnection {
     start(isOffering: boolean): void
 
     on(event: 'localDescription', listener: (description: string, type: string) => void): this

package/src/connection/{WebRTC/NodeWebRtcConnection.ts → webrtc/NodeWebrtcConnection.ts}

@@ -1,19 +1,18 @@
-import { IWebRtcConnection, WebRtcConnectionEvents } from './IWebRtcConnection'
+import { IWebrtcConnection, WebrtcConnectionEvents } from './IWebrtcConnection'
 import { ConnectionType, IConnection, ConnectionID, ConnectionEvents } from '../IConnection'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import EventEmitter from 'eventemitter3'
 import nodeDatachannel, { DataChannel, DescriptionType, PeerConnection } from 'node-datachannel'
 import { Logger } from '@streamr/utils'
-import { IllegalRTCPeerConnectionState } from '../../helpers/errors'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { DisconnectionType } from '../../transport/ITransport'
+import { IllegalRtcPeerConnectionState } from '../../helpers/errors'
+import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { iceServerAsString } from './iceServerAsString'
-import { IceServer } from './WebRtcConnectorRpcLocal'
+import { IceServer } from './WebrtcConnector'
 import { PortRange } from '../ConnectionManager'
 
 const logger = new Logger(module)
 
-export const WEB_RTC_CLEANUP = new class {
+export const WEBRTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
         nodeDatachannel.cleanup()
@@ -33,7 +32,7 @@ export interface Params {
 // Re-defined accoring to https://github.com/microsoft/TypeScript/blob/main/src/lib/dom.generated.d.ts
 // because importing single dom definitions in not possible
 
-enum RTCPeerConnectionStateEnum {
+enum RtcPeerConnectionStateEnum {
     closed = 'closed',
     connected = 'connected',
     connecting = 'connecting',
@@ -44,16 +43,16 @@ enum RTCPeerConnectionStateEnum {
 
 nodeDatachannel.initLogger('Fatal')
 
-type RTCPeerConnectionState = keyof typeof RTCPeerConnectionStateEnum
+type RtcPeerConnectionState = keyof typeof RtcPeerConnectionStateEnum
 
-type Events = WebRtcConnectionEvents & ConnectionEvents
+type Events = WebrtcConnectionEvents & ConnectionEvents
 
-export class NodeWebRtcConnection extends EventEmitter<Events> implements IConnection, IWebRtcConnection {
+export class NodeWebrtcConnection extends EventEmitter<Events> implements IConnection, IWebrtcConnection {
 
     public connectionId: ConnectionID
     private connection?: PeerConnection
     private dataChannel?: DataChannel
-    private lastState: RTCPeerConnectionState = 'connecting'
+    private lastState: RtcPeerConnectionState = 'connecting'
     private remoteDescriptionSet = false
     private connectingTimeoutRef?: NodeJS.Timeout
 
@@ -81,9 +80,8 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
     }
 
     public start(isOffering: boolean): void {
-        logger.trace(`Staring new connection for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
         const peerIdKey = keyFromPeerDescriptor(this.remotePeerDescriptor)
-        logger.trace(`Staring new connection for peer: ${peerIdKey} offering: ${isOffering}`)
+        logger.trace(`Starting new connection for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`, { isOffering })
         this.connection = new PeerConnection(peerIdKey, {
             iceServers: this.iceServers.map(iceServerAsString),
             maxMessageSize: this.maxMessageSize,
@@ -93,7 +91,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
         this.connectingTimeoutRef = setTimeout(() => {
             logger.trace('connectingTimeout, this.closed === ' + this.closed)
-            this.doClose('OTHER')
+            this.doClose(false)
         }, this.connectingTimeout)
 
         this.connection.onStateChange((state: string) => this.onStateChange(state))
@@ -116,14 +114,14 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
     public async setRemoteDescription(description: string, type: string): Promise<void> {
         if (this.connection) {
             try {
-                logger.trace(`Setting remote descriptor for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.trace(`Setting remote descriptor for peer: ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
                 this.connection.setRemoteDescription(description, type as DescriptionType)
                 this.remoteDescriptionSet = true
             } catch (err) {
-                logger.warn(`Failed to set remote descriptor for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                logger.debug(`Failed to set remote descriptor for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
             }
         } else {
-            this.doClose('OTHER', `Tried to set description for non-existent connection`)
+            this.doClose(false, `Tried to set description for non-existent connection`)
         }
     }
 
@@ -131,17 +129,17 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
         if (this.connection) {
             if (this.remoteDescriptionSet) {
                 try {
-                    logger.trace(`Setting remote candidate for peer: ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+                    logger.trace(`Setting remote candidate for peer: ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
                     this.connection.addRemoteCandidate(candidate, mid)
                 } catch (err) {
-                    logger.warn(`Failed to set remote candidate for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
-                    this.doClose('OTHER')
+                    logger.debug(`Failed to set remote candidate for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
                 }
             } else {
-                this.doClose('OTHER', `Tried to set candidate before description`)
+                // TODO: should queue candidates until remote description is set?
+                this.doClose(false, `Tried to set candidate before description`)
             }
         } else {
-            this.doClose('OTHER', `Tried to set candidate for non-existent connection`)
+            this.doClose(false, `Tried to set candidate for non-existent connection`)
         }
     }
 
@@ -150,25 +148,25 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
             try {
                 this.dataChannel!.sendMessageBinary(data as Buffer)
             } catch (err) {
-                logger.warn('Failed to send binary message to ' + keyFromPeerDescriptor(this.remotePeerDescriptor) + err)
+                logger.debug('Failed to send binary message to ' + getNodeIdFromPeerDescriptor(this.remotePeerDescriptor) + err)
             }
         }
     }
 
-    public async close(disconnectionType: DisconnectionType, reason?: string): Promise<void> {
-        this.doClose(disconnectionType, reason)
+    public async close(gracefulLeave: boolean, reason?: string): Promise<void> {
+        this.doClose(gracefulLeave, reason)
     }
 
-    private doClose(disconnectionType: DisconnectionType, reason?: string): void {
+    private doClose(gracefulLeave: boolean, reason?: string): void {
         if (!this.closed) {
             logger.trace(
-                `Closing Node WebRTC Connection to ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`
+                `Closing Node WebRTC Connection to ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`
                 + `${reason ? `, reason: ${reason}` : ''}`
             )
 
             this.closed = true
             
-            this.emit('disconnected', disconnectionType, undefined, reason)
+            this.emit('disconnected', gracefulLeave, undefined, reason)
             this.removeAllListeners()
             
             if (this.connectingTimeoutRef) {
@@ -180,7 +178,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
                     logger.trace('closing datachannel')
                     this.dataChannel.close()
                 } catch (e) {
-                    logger.warn('dc.close() errored: %s', e)
+                    logger.trace('dc.close() errored: %s', e)
                 }
             }
             
@@ -188,7 +186,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
                 try {
                     this.connection.close()
                 } catch (e) {
-                    logger.warn('conn.close() errored: %s', e)
+                    logger.trace('conn.close() errored: %s', e)
                 }
             }
         }
@@ -196,7 +194,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
     public destroy(): void {
         this.removeAllListeners()
-        this.doClose('OTHER')
+        this.doClose(false)
     }
 
     private onDataChannel(dataChannel: DataChannel): void {
@@ -213,7 +211,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
 
         dataChannel.onClosed(() => {
             logger.trace(`dc.closed`)
-            this.doClose('OTHER', 'DataChannel closed')
+            this.doClose(false, 'DataChannel closed')
         })
 
         dataChannel.onError((err) => logger.error('error', { err }))
@@ -233,23 +231,23 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
             clearTimeout(this.connectingTimeoutRef)
         }
         this.dataChannel = dataChannel
-        logger.trace(`DataChannel opened for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
+        logger.trace(`DataChannel opened for peer ${getNodeIdFromPeerDescriptor(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }
 
     private onStateChange(state: string): void {
         logger.trace('onStateChange ' + state)
-        if (!Object.keys(RTCPeerConnectionStateEnum).filter((s) => isNaN(+s)).includes(state)) {
-            throw new IllegalRTCPeerConnectionState('NodeWebRtcConnection used an unknown state: ' + state)
+        if (!Object.keys(RtcPeerConnectionStateEnum).filter((s) => isNaN(+s)).includes(state)) {
+            throw new IllegalRtcPeerConnectionState('NodeWebrtcConnection used an unknown state: ' + state)
         } else {
-            this.lastState = state as RTCPeerConnectionState
+            this.lastState = state as RtcPeerConnectionState
         }
         
-        if (state === RTCPeerConnectionStateEnum.closed
-            || state === RTCPeerConnectionStateEnum.disconnected
-            || state === RTCPeerConnectionStateEnum.failed
+        if (state === RtcPeerConnectionStateEnum.closed
+            || state === RtcPeerConnectionStateEnum.disconnected
+            || state === RtcPeerConnectionStateEnum.failed
         ) {
-            this.doClose('OTHER')
+            this.doClose(false)
         }
         
     }

package/src/connection/webrtc/WebrtcConnector.ts

@@ -0,0 +1,226 @@
+import {
+    IceCandidate,
+    PeerDescriptor,
+    RtcAnswer,
+    RtcOffer, WebrtcConnectionRequest
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { ITransport } from '../../transport/ITransport'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+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'
+
+const logger = new Logger(module)
+
+export const replaceInternalIpWithExternalIp = (candidate: string, ip: string): string => {
+    const parsed = candidate.split(' ')
+    const type = parsed[7]
+    if (type === 'host') {
+        parsed[4] = ip
+    }
+    return parsed.join(' ')
+}
+
+export interface WebrtcConnectorConfig {
+    transport: ITransport
+    iceServers?: IceServer[]
+    allowPrivateAddresses?: boolean
+    bufferThresholdLow?: number
+    bufferThresholdHigh?: number
+    maxMessageSize?: number
+    connectionTimeout?: number
+    externalIp?: string
+    portRange?: PortRange
+}
+
+export interface IceServer {
+    url: string
+    port: number
+    username?: string
+    password?: string
+    tcp?: boolean
+}
+
+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 localPeerDescriptor?: PeerDescriptor
+    private stopped = false
+    private iceServers: IceServer[]
+    private config: WebrtcConnectorConfig
+
+    constructor(
+        config: WebrtcConnectorConfig,
+        onNewConnection: (connection: ManagedConnection) => boolean
+    ) {
+        this.config = config
+        this.iceServers = config.iceServers ?? []
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
+            rpcRequestTimeout: 15000
+        })
+        this.registerLocalRpcMethods(config, onNewConnection)
+    }
+
+    private registerLocalRpcMethods(
+        config: WebrtcConnectorConfig,
+        onNewConnection: (connection: ManagedConnection) => boolean
+    ) {
+        const localRpc = new WebrtcConnectorRpcLocal({
+            connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
+            onNewConnection,
+            ongoingConnectAttempts: this.ongoingConnectAttempts,
+            rpcCommunicator: this.rpcCommunicator,
+            getLocalPeerDescriptor: () => this.localPeerDescriptor!,
+            allowPrivateAddresses: config.allowPrivateAddresses ?? true
+        })
+        this.rpcCommunicator.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection',
+            async (_req: WebrtcConnectionRequest, context: ServerCallContext) => {
+                if (!this.stopped) {
+                    return localRpc.requestConnection(context)
+                } else {
+                    return {}
+                }
+            }
+        )
+        this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
+            async (req: RtcOffer, context: ServerCallContext) => {
+                if (!this.stopped) {
+                    return localRpc.rtcOffer(req, context)
+                } else {
+                    return {}
+                }
+            }
+        )
+        this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
+            async (req: RtcAnswer, context: ServerCallContext) => {
+                if (!this.stopped) {
+                    return localRpc.rtcAnswer(req, context)
+                } else {
+                    return {}
+                }
+            }
+        )
+        this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
+            async (req: IceCandidate, context: ServerCallContext) => {
+                if (!this.stopped) {
+                    return localRpc.iceCandidate(req, context)
+                } else {
+                    return {}
+                }
+            }
+        )
+    }
+
+    connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
+        if (areEqualPeerDescriptors(targetPeerDescriptor, this.localPeerDescriptor!)) {
+            throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
+        }
+
+        logger.trace(`Opening WebRTC connection to ${getNodeIdFromPeerDescriptor(targetPeerDescriptor)}`)
+
+        const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
+        const existingConnection = this.ongoingConnectAttempts.get(peerKey)
+        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 offering = this.isOffering(targetPeerDescriptor)
+        let managedConnection: ManagedWebrtcConnection
+
+        if (offering) {
+            managedConnection = new ManagedWebrtcConnection(this.localPeerDescriptor!, connection)
+        } else {
+            managedConnection = new ManagedWebrtcConnection(this.localPeerDescriptor!, undefined, connection)
+        }
+
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
+
+        this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
+
+        const delFunc = () => {
+            this.ongoingConnectAttempts.delete(peerKey)
+            connection.off('disconnected', delFunc)
+            managedConnection.off('handshakeCompleted', delFunc)
+        }
+        connection.on('disconnected', delFunc)
+        managedConnection.on('handshakeCompleted', delFunc)
+
+        const remoteConnector = new WebrtcConnectorRpcRemote(
+            this.localPeerDescriptor!,
+            targetPeerDescriptor,
+            toProtoRpcClient(new WebrtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+        )
+
+        connection.on('localCandidate', (candidate: string, mid: string) => {
+            if (this.config.externalIp) {
+                candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
+                logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
+            }
+            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId.toString())
+        })
+
+        if (offering) {
+            connection.once('localDescription', (description: string) => {
+                remoteConnector.sendRtcOffer(description, connection.connectionId.toString())
+            })
+        } else {
+            connection.once('localDescription', (description: string) => {
+                remoteConnector.sendRtcAnswer(description, connection.connectionId.toString())
+            })
+        }
+
+        connection.start(offering)
+
+        if (!offering) {
+            remoteConnector.requestConnection()
+        }
+
+        return managedConnection
+    }
+
+    setLocalPeerDescriptor(peerDescriptor: PeerDescriptor): void {
+        this.localPeerDescriptor = peerDescriptor
+    }
+
+    public async stop(): Promise<void> {
+        logger.trace('stop()')
+        this.stopped = true
+
+        const attempts = Array.from(this.ongoingConnectAttempts.values())
+        await Promise.allSettled(attempts.map((conn) => conn.close(false)))
+
+        this.rpcCommunicator.destroy()
+    }
+
+    public isOffering(targetPeerDescriptor: PeerDescriptor): boolean {
+        const myId = peerIdFromPeerDescriptor(this.localPeerDescriptor!)
+        const theirId = peerIdFromPeerDescriptor(targetPeerDescriptor)
+        return myId.hasSmallerHashThan(theirId)
+    }
+}