@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/connection/Simulator/SimulatorConnector.ts

@@ -16,25 +16,22 @@ export class SimulatorConnector {
 
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
     private stopped = false
-    private protocolVersion: string
     private ownPeerDescriptor: PeerDescriptor
     private simulator: Simulator
-    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
+    private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
-        protocolVersion: string,
         ownPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
-        incomingConnectionCallback: (connection: ManagedConnection) => boolean
+        onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
-        this.protocolVersion = protocolVersion
         this.ownPeerDescriptor = ownPeerDescriptor
         this.simulator = simulator
-        this.incomingConnectionCallback = incomingConnectionCallback
+        this.onIncomingConnection = onIncomingConnection
     }
 
     public connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        logger.trace('connect() ' + this.ownPeerDescriptor.nodeName + ',' + targetPeerDescriptor.nodeName)
+        logger.trace('connect() ' + keyFromPeerDescriptor(targetPeerDescriptor))
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.connectingConnections.get(peerKey)
         if (existingConnection) {
@@ -43,8 +40,7 @@ export class SimulatorConnector {
 
         const connection = new SimulatorConnection(this.ownPeerDescriptor, targetPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, this.protocolVersion,
-            ConnectionType.SIMULATOR_CLIENT, connection, undefined)
+        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, ConnectionType.SIMULATOR_CLIENT, connection, undefined)
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
         this.connectingConnections.set(peerKey, managedConnection)
@@ -65,25 +61,23 @@ export class SimulatorConnector {
     }
 
     public handleIncomingConnection(sourceConnection: SimulatorConnection): void {
-        logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName +
-            ' incoming connection, stopped: ' + this.stopped)
+        logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming connection, stopped: ' + this.stopped)
         if (this.stopped) {
             return
         }
         const connection = new SimulatorConnection(this.ownPeerDescriptor,
             sourceConnection.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, this.simulator)
 
-        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, this.protocolVersion,
-            ConnectionType.SIMULATOR_SERVER, undefined, connection)
+        const managedConnection = new ManagedConnection(this.ownPeerDescriptor, ConnectionType.SIMULATOR_SERVER, undefined, connection)
 
-        logger.trace('connected, objectId: ' + managedConnection.objectId)
+        logger.trace('connected')
 
-        managedConnection.once('handshakeRequest', (_peerDescriptor: PeerDescriptor) => {
-            logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName + ' incoming handshake request')
-            logger.trace('incoming handshake request objectId: ' + managedConnection.objectId)
+        managedConnection.once('handshakeRequest', () => {
+            logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' incoming handshake request')
+            logger.trace('incoming handshake request')
 
-            if (this.incomingConnectionCallback(managedConnection)) {
-                logger.trace(' ' + this.ownPeerDescriptor.nodeName + ', ' + sourceConnection.ownPeerDescriptor.nodeName + ' calling acceptHandshake')
+            if (this.onIncomingConnection(managedConnection)) {
+                logger.trace(keyFromPeerDescriptor(sourceConnection.ownPeerDescriptor) + ' calling acceptHandshake')
                 managedConnection.acceptHandshake()
             } else {
                 managedConnection.rejectHandshake('Duplicate connection')

package/src/connection/Simulator/SimulatorTransport.ts

@@ -1,9 +1,14 @@
+import { MetricsContext } from '@streamr/utils'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ConnectionManager } from '../ConnectionManager'
 import { Simulator } from './Simulator'
+import { SimulatorConnectorFacade } from '../ConnectorFacade'
 
 export class SimulatorTransport extends ConnectionManager {
     constructor(ownPeerDescriptor: PeerDescriptor, simulator: Simulator) {
-        super({ ownPeerDescriptor: ownPeerDescriptor, simulator, serviceIdPrefix: 'simulator/' })
+        super({
+            createConnectorFacade: () => new SimulatorConnectorFacade(ownPeerDescriptor, simulator),
+            metricsContext: new MetricsContext()
+        })
     }
 }

package/src/connection/WebRTC/NodeWebRtcConnection.ts

@@ -8,13 +8,11 @@ import { IllegalRTCPeerConnectionState } from '../../helpers/errors'
 import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { DisconnectionType } from '../../transport/ITransport'
 import { iceServerAsString } from './iceServerAsString'
-import { IceServer } from './WebRtcConnector'
+import { IceServer } from './WebRtcConnectorRpcLocal'
 import { PortRange } from '../ConnectionManager'
 
 const logger = new Logger(module)
 
-const MAX_MESSAGE_SIZE = 1048576
-
 export const WEB_RTC_CLEANUP = new class {
     // eslint-disable-next-line class-methods-use-this
     cleanUp(): void {
@@ -27,6 +25,7 @@ export interface Params {
     bufferThresholdHigh?: number
     bufferThresholdLow?: number
     connectingTimeout?: number
+    maxMessageSize?: number
     iceServers?: IceServer[]
     portRange?: PortRange
 }
@@ -65,27 +64,29 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
     private readonly connectingTimeout: number
     private readonly remotePeerDescriptor: PeerDescriptor
     private readonly portRange?: PortRange
+    private readonly maxMessageSize?: number
     private closed = false
 
     constructor(params: Params) {
         super()
         this.connectionId = new ConnectionID()
-        this.iceServers = params.iceServers || []
+        this.iceServers = params.iceServers ?? []
         // eslint-disable-next-line no-underscore-dangle
-        this._bufferThresholdHigh = params.bufferThresholdHigh || 2 ** 17
-        this.bufferThresholdLow = params.bufferThresholdLow || 2 ** 15
-        this.connectingTimeout = params.connectingTimeout || 20000
+        this._bufferThresholdHigh = params.bufferThresholdHigh ?? 2 ** 17
+        this.bufferThresholdLow = params.bufferThresholdLow ?? 2 ** 15
+        this.connectingTimeout = params.connectingTimeout ?? 20000
         this.remotePeerDescriptor = params.remotePeerDescriptor
+        this.maxMessageSize = params.maxMessageSize ?? 1048576
         this.portRange = params.portRange
     }
 
     public start(isOffering: boolean): void {
-        logger.trace(`Staring new connection for peer: ${this.remotePeerDescriptor.kademliaId.toString()}`)
-        const hexId = keyFromPeerDescriptor(this.remotePeerDescriptor)
-        logger.trace(`Staring new connection for peer: ${hexId} offering: ${isOffering}`)
-        this.connection = new PeerConnection(hexId, {
+        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}`)
+        this.connection = new PeerConnection(peerIdKey, {
             iceServers: this.iceServers.map(iceServerAsString),
-            maxMessageSize: MAX_MESSAGE_SIZE,
+            maxMessageSize: this.maxMessageSize,
             portRangeBegin: this.portRange?.min,
             portRangeEnd: this.portRange?.max,
         })
@@ -96,7 +97,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
         }, this.connectingTimeout)
 
         this.connection.onStateChange((state: string) => this.onStateChange(state))
-        this.connection.onGatheringStateChange((_state: string) => {})
+        this.connection.onGatheringStateChange(() => {})
 
         this.connection.onLocalDescription((description: string, type: DescriptionType) => {
             this.emit('localDescription', description, type.toString())
@@ -232,7 +233,7 @@ export class NodeWebRtcConnection extends EventEmitter<Events> implements IConne
             clearTimeout(this.connectingTimeoutRef)
         }
         this.dataChannel = dataChannel
-        logger.trace(`DataChannel opened for peer ${this.remotePeerDescriptor.kademliaId.toString()}`)
+        logger.trace(`DataChannel opened for peer ${keyFromPeerDescriptor(this.remotePeerDescriptor)}`)
         this.emit('connected')
     }
 

package/src/connection/WebRTC/{WebRtcConnector.ts → WebRtcConnectorRpcLocal.ts}

@@ -8,23 +8,24 @@ import { Empty } from '../../proto/google/protobuf/empty'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { NodeWebRtcConnection } from './NodeWebRtcConnection'
-import { RemoteWebrtcConnector } from './RemoteWebrtcConnector'
-import { WebRtcConnectorServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+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 { IWebRtcConnectorService } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { IWebRtcConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { ManagedConnection } from '../ManagedConnection'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
-    isSamePeerDescriptor,
+    areEqualPeerDescriptors,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
 import { getAddressFromIceCandidate, isPrivateIPv4 } from '../../helpers/AddressTools'
 import { PortRange } from '../ConnectionManager'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 
 const logger = new Logger(module)
 
@@ -37,13 +38,13 @@ export const replaceInternalIpWithExternalIp = (candidate: string, ip: string):
     return parsed.join(' ')
 }
 
-export interface WebRtcConnectorConfig {
-    rpcTransport: ITransport
-    protocolVersion: string
+export interface WebRtcConnectorRpcLocalConfig {
+    transport: ITransport
     iceServers?: IceServer[]
     allowPrivateAddresses?: boolean
     bufferThresholdLow?: number
     bufferThresholdHigh?: number
+    maxMessageSize?: number
     connectionTimeout?: number
     externalIp?: string
     portRange?: PortRange
@@ -57,45 +58,46 @@ export interface IceServer {
     tcp?: boolean
 }
 
-export class WebRtcConnector implements IWebRtcConnectorService {
-    private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc_connector'
+export class WebRtcConnectorRpcLocal implements IWebRtcConnectorRpc {
+
+    private static readonly WEBRTC_CONNECTOR_SERVICE_ID = 'system/webrtc-connector'
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly ongoingConnectAttempts: Map<PeerIDKey, ManagedWebRtcConnection> = new Map()
     private ownPeerDescriptor?: PeerDescriptor
     private stopped = false
     private iceServers: IceServer[]
     private allowPrivateAddresses: boolean
-    private config: WebRtcConnectorConfig
-    private incomingConnectionCallback: (connection: ManagedConnection) => boolean
+    private config: WebRtcConnectorRpcLocalConfig
+    private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
-        config: WebRtcConnectorConfig,
-        incomingConnectionCallback: (connection: ManagedConnection) => boolean
+        config: WebRtcConnectorRpcLocalConfig,
+        onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
         this.config = config
         this.iceServers = config.iceServers || []
         this.allowPrivateAddresses = config.allowPrivateAddresses || true
-        this.incomingConnectionCallback = incomingConnectionCallback
+        this.onIncomingConnection = onIncomingConnection
 
-        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.rpcTransport, {
+        this.rpcCommunicator = new ListeningRpcCommunicator(WebRtcConnectorRpcLocal.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
         this.rpcCommunicator.registerRpcNotification(RtcOffer, 'rtcOffer',
-            (req: RtcOffer, context) => this.rtcOffer(req, context))
+            (req: RtcOffer, context: ServerCallContext) => this.rtcOffer(req, context))
         this.rpcCommunicator.registerRpcNotification(RtcAnswer, 'rtcAnswer',
-            (req: RtcAnswer, context) => this.rtcAnswer(req, context))
+            (req: RtcAnswer, context: ServerCallContext) => this.rtcAnswer(req, context))
         this.rpcCommunicator.registerRpcNotification(IceCandidate, 'iceCandidate',
-            (req: IceCandidate, context) => this.iceCandidate(req, context))
+            (req: IceCandidate, context: ServerCallContext) => this.iceCandidate(req, context))
         this.rpcCommunicator.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection',
-            (req: WebRtcConnectionRequest, context) => this.requestConnection(req, context))
+            (req: WebRtcConnectionRequest, context: ServerCallContext) => this.requestConnection(req, context))
     }
 
     connect(targetPeerDescriptor: PeerDescriptor): ManagedConnection {
-        if (isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+        if (areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
             throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
         }
 
-        logger.trace(`Opening WebRTC connection to ${targetPeerDescriptor.kademliaId.toString()}`)
+        logger.trace(`Opening WebRTC connection to ${keyFromPeerDescriptor(targetPeerDescriptor)}`)
 
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.ongoingConnectAttempts.get(peerKey)
@@ -103,7 +105,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
             return existingConnection
         }
 
-        const connection = new NodeWebRtcConnection({ 
+        const connection = new NodeWebRtcConnection({
             remotePeerDescriptor: targetPeerDescriptor,
             iceServers: this.iceServers,
             bufferThresholdLow: this.config.bufferThresholdLow,
@@ -116,9 +118,9 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         let managedConnection: ManagedWebRtcConnection
 
         if (offering) {
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, connection)
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, connection)
         } else {
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, undefined, connection)
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, undefined, connection)
         }
 
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
@@ -135,9 +137,10 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         connection.on('disconnected', delFunc)
         managedConnection.on('handshakeCompleted', delFunc)
 
-        const remoteConnector = new RemoteWebrtcConnector(
+        const remoteConnector = new WebRtcConnectorRpcRemote(
+            this.ownPeerDescriptor!,
             targetPeerDescriptor,
-            toProtoRpcClient(new WebRtcConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new WebRtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
         )
 
         connection.on('localCandidate', (candidate: string, mid: string) => {
@@ -145,23 +148,23 @@ export class WebRtcConnector implements IWebRtcConnectorService {
                 candidate = replaceInternalIpWithExternalIp(candidate, this.config.externalIp)
                 logger.debug(`onLocalCandidate injected external ip ${candidate} ${mid}`)
             }
-            remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection.connectionId.toString())
+            remoteConnector.sendIceCandidate(candidate, mid, connection.connectionId.toString())
         })
 
         if (offering) {
-            connection.once('localDescription', (description: string, _type: string) => {
-                remoteConnector.sendRtcOffer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
+            connection.once('localDescription', (description: string) => {
+                remoteConnector.sendRtcOffer(description, connection.connectionId.toString())
             })
         } else {
-            connection.once('localDescription', (description: string, _type: string) => {
-                remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection.connectionId.toString())
+            connection.once('localDescription', (description: string) => {
+                remoteConnector.sendRtcAnswer(description, connection.connectionId.toString())
             })
         }
 
         connection.start(offering)
 
         if (!offering) {
-            remoteConnector.requestConnection(this.ownPeerDescriptor!, connection.connectionId.toString())
+            remoteConnector.requestConnection(connection.connectionId.toString())
         }
 
         return managedConnection
@@ -171,7 +174,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         this.ownPeerDescriptor = peerDescriptor
     }
 
-    isIceCandidateAllowed(candidate: string): boolean {
+    private isIceCandidateAllowed(candidate: string): boolean {
         if (!this.allowPrivateAddresses) {
             const address = getAddressFromIceCandidate(candidate)
             if (address && isPrivateIPv4(address)) {
@@ -187,7 +190,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         description: string,
         connectionId: string
     ): void {
-        if (this.stopped || !isSamePeerDescriptor(targetPeer, this.ownPeerDescriptor!)) {
+        if (this.stopped || !areEqualPeerDescriptors(targetPeer, this.ownPeerDescriptor!)) {
             return
         }
         const peerKey = keyFromPeerDescriptor(remotePeer)
@@ -196,24 +199,25 @@ export class WebRtcConnector implements IWebRtcConnectorService {
 
         if (!managedConnection) {
             connection = new NodeWebRtcConnection({ remotePeerDescriptor: remotePeer })
-            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, this.config.protocolVersion, undefined, connection)
-            
+            managedConnection = new ManagedWebRtcConnection(this.ownPeerDescriptor!, undefined, connection)
+
             managedConnection.setPeerDescriptor(remotePeer)
 
             this.ongoingConnectAttempts.set(peerKey, managedConnection)
-            this.incomingConnectionCallback(managedConnection)
+            this.onIncomingConnection(managedConnection)
 
-            const remoteConnector = new RemoteWebrtcConnector(
+            const remoteConnector = new WebRtcConnectorRpcRemote(
+                this.ownPeerDescriptor!,
                 remotePeer,
-                toProtoRpcClient(new WebRtcConnectorServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new WebRtcConnectorRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
 
             connection.on('localCandidate', (candidate: string, mid: string) => {
-                remoteConnector.sendIceCandidate(this.ownPeerDescriptor!, candidate, mid, connection!.connectionId.toString())
+                remoteConnector.sendIceCandidate(candidate, mid, connection!.connectionId.toString())
             })
 
-            connection.once('localDescription', (description: string, _type: string) => {
-                remoteConnector.sendRtcAnswer(this.ownPeerDescriptor!, description, connection!.connectionId.toString())
+            connection.once('localDescription', (description: string) => {
+                remoteConnector.sendRtcAnswer(description, connection!.connectionId.toString())
             })
 
             connection.start(false)
@@ -223,7 +227,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         // Always use offerers connectionId
         connection!.setConnectionId(connectionId)
         connection!.setRemoteDescription(description, 'offer')
-        
+
         managedConnection.on('handshakeRequest', () => {
             if (this.ongoingConnectAttempts.has(peerKey)) {
                 this.ongoingConnectAttempts.delete(peerKey)
@@ -238,7 +242,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         description: string,
         connectionId: string
     ): void {
-        if (this.stopped || !isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+        if (this.stopped || !areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
             return
         }
         const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
@@ -259,7 +263,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         const managedConnection = this.connect(targetPeerDescriptor)
         managedConnection.setPeerDescriptor(targetPeerDescriptor)
 
-        this.incomingConnectionCallback(managedConnection)
+        this.onIncomingConnection(managedConnection)
     }
     private onRemoteCandidate(
         remotePeerDescriptor: PeerDescriptor,
@@ -268,7 +272,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
         mid: string,
         connectionId: string
     ): void {
-        if (this.stopped || !isSamePeerDescriptor(targetPeerDescriptor, this.ownPeerDescriptor!)) {
+        if (this.stopped || !areEqualPeerDescriptors(targetPeerDescriptor, this.ownPeerDescriptor!)) {
             return
         }
         const peerKey = keyFromPeerDescriptor(remotePeerDescriptor)
@@ -290,7 +294,7 @@ export class WebRtcConnector implements IWebRtcConnectorService {
 
         const attempts = Array.from(this.ongoingConnectAttempts.values())
         await Promise.allSettled(attempts.map((conn) => conn.close('OTHER')))
-       
+
         this.rpcCommunicator.stop()
     }
 
@@ -301,23 +305,31 @@ export class WebRtcConnector implements IWebRtcConnectorService {
     }
 
     // IWebRTCConnector implementation
-    async requestConnection(request: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> {
-        this.onConnectionRequest(request.requester!)
+    // TODO should we read connectionId from WebRtcConnectionRequest (or remove the field)?
+    async requestConnection(_request: WebRtcConnectionRequest, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        this.onConnectionRequest(senderPeerDescriptor)
         return {}
     }
 
-    async rtcOffer(request: RtcOffer, _context: ServerCallContext): Promise<Empty> {
-        this.onRtcOffer(request.requester!, request.target!, request.description, request.connectionId)
+    async rtcOffer(request: RtcOffer, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
+        this.onRtcOffer(senderPeerDescriptor, receiverPeerDescriptor, request.description, request.connectionId)
         return {}
     }
 
-    async rtcAnswer(request: RtcAnswer, _context: ServerCallContext): Promise<Empty> {
-        this.onRtcAnswer(request.requester!, request.target!, request.description, request.connectionId)
+    async rtcAnswer(request: RtcAnswer, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
+        this.onRtcAnswer(senderPeerDescriptor, receiverPeerDescriptor, request.description, request.connectionId)
         return {}
     }
 
-    async iceCandidate(request: IceCandidate, _context: ServerCallContext): Promise<Empty> {
-        this.onRemoteCandidate(request.requester!, request.target!, request.candidate, request.mid, request.connectionId)
+    async iceCandidate(request: IceCandidate, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const receiverPeerDescriptor = (context as DhtCallContext).incomingTargetDescriptor!
+        this.onRemoteCandidate(senderPeerDescriptor, receiverPeerDescriptor, request.candidate, request.mid, request.connectionId)
         return {}
     }
 }

package/src/connection/WebRTC/WebRtcConnectorRpcRemote.ts

@@ -0,0 +1,71 @@
+import { Remote } from '../../dht/contact/Remote'
+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'
+
+const logger = new Logger(module)
+
+export class WebRtcConnectorRpcRemote extends Remote<IWebRtcConnectorRpcClient> {
+
+    constructor(
+        localPeerDescriptor: PeerDescriptor,
+        remotePeerDescriptor: PeerDescriptor,
+        client: ProtoRpcClient<IWebRtcConnectorRpcClient>
+    ) {
+        super(localPeerDescriptor, remotePeerDescriptor, 'DUMMY', client)
+    }
+
+    requestConnection(connectionId: string): void {
+        const request: WebRtcConnectionRequest = {
+            connectionId
+        }
+        const options = this.formDhtRpcOptions({
+            notification: true
+        })
+        this.getClient().requestConnection(request, options).catch((_e) => {
+            logger.trace('Failed to send requestConnection')
+        })
+    }
+
+    sendRtcOffer(description: string, connectionId: string): void {
+        const request: RtcOffer = {
+            connectionId,
+            description
+        }
+        const options = this.formDhtRpcOptions()
+        this.getClient().rtcOffer(request, options).catch((_e) => {
+            logger.trace('Failed to send rtcOffer')
+        })
+    }
+
+    sendRtcAnswer(description: string, connectionId: string): void {
+        const request: RtcAnswer = {
+            connectionId,
+            description
+        }
+        const options = this.formDhtRpcOptions()
+        this.getClient().rtcAnswer(request, options).catch((_e) => {
+            logger.trace('Failed to send rtcAnswer')
+        })
+    }
+
+    sendIceCandidate(candidate: string, mid: string, connectionId: string): void {
+        const request: IceCandidate = {
+            connectionId,
+            mid,
+            candidate
+        }
+        const options = this.formDhtRpcOptions()
+        this.getClient().iceCandidate(request, options).catch((_e) => {
+            logger.trace('Failed to send iceCandidate')
+        })
+    }
+}
+

package/src/connection/WebRTC/iceServerAsString.ts

@@ -1,4 +1,4 @@
-import { IceServer } from './WebRtcConnector'
+import { IceServer } from './WebRtcConnectorRpcLocal'
 
 export function iceServerAsString({ url, port, username, password, tcp }: IceServer): string {
     const [protocol, hostname] = url.split(':')