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

package/protos/DhtRpc.proto

@@ -14,40 +14,40 @@ service DhtRpcService {
   rpc leaveNotice (LeaveNotice) returns (google.protobuf.Empty);
 }
 
-service RoutingService {
+service RouterRpc {
   rpc routeMessage (RouteMessageWrapper) returns (RouteMessageAck);
   rpc forwardMessage (RouteMessageWrapper) returns (RouteMessageAck);
   rpc findRecursively (RouteMessageWrapper) returns (RouteMessageAck);
 }
 
-service StoreService {
+service StoreRpc {
   rpc storeData (StoreDataRequest) returns (StoreDataResponse);
   rpc migrateData (MigrateDataRequest) returns (MigrateDataResponse);
   rpc deleteData (DeleteDataRequest) returns (DeleteDataResponse);
 }
 
 service RecursiveFindSessionService {
-  rpc reportRecursiveFindResult(RecursiveFindReport) returns (google.protobuf.Empty);
+  rpc sendFindResponse(FindResponse) returns (google.protobuf.Empty);
 }
 
-service WebSocketConnectorService {
+service WebSocketConnectorRpc {
   rpc requestConnection (WebSocketConnectionRequest) returns (WebSocketConnectionResponse);
 }
 
-service WebRtcConnectorService {
+service WebRtcConnectorRpc {
   rpc requestConnection (WebRtcConnectionRequest) returns (google.protobuf.Empty);
   rpc rtcOffer (RtcOffer) returns (google.protobuf.Empty);
   rpc rtcAnswer (RtcAnswer) returns (google.protobuf.Empty);
   rpc iceCandidate (IceCandidate) returns (google.protobuf.Empty);
 }
 
-service ConnectionLocker {
+service ConnectionLockRpc {
   rpc lockRequest (LockRequest) returns (LockResponse);
   rpc unlockRequest (UnlockRequest) returns (google.protobuf.Empty);
   rpc gracefulDisconnect (DisconnectNotice) returns (DisconnectNoticeResponse);
 }
 
-service ExternalApiService {
+service ExternalApiRpc {
   rpc findData (FindDataRequest) returns (FindDataResponse);
   rpc externalStoreData (ExternalStoreDataRequest) returns (ExternalStoreDataResponse);
 }
@@ -111,18 +111,13 @@ message ClosestPeersResponse {
   string requestId = 2;
 }
 
-enum FindMode {
-  NODE = 0;
-  DATA = 1;
+message FindRequest {
+  string sessionId = 1;
+  bool fetchData = 2;
 }
 
-message RecursiveFindRequest {
-  string recursiveFindSessionId = 1;
-  FindMode findMode = 2;
-}
-
-message RecursiveFindReport {
-  repeated PeerDescriptor nodes = 1;
+message FindResponse {
+  repeated PeerDescriptor closestConnectedPeers = 1;
   repeated DataEntry dataEntries = 2;
   optional bool noCloserNodesFound = 3;
   repeated PeerDescriptor routingPath = 4;
@@ -180,10 +175,8 @@ message RouteMessageWrapper {
 }
 
 message RouteMessageAck {
-  PeerDescriptor sourcePeer = 1;
-  string requestId = 2;
-  PeerDescriptor destinationPeer = 3;
-  string error = 4;
+  string requestId = 1;
+  string error = 2;
 }
 
 // Correspond to the MessageType Enum
@@ -203,15 +196,13 @@ message ConnectivityResponse {
 
 message HandshakeRequest {
   bytes sourceId = 1;
-  string protocolVersion = 2;
-  PeerDescriptor peerDescriptor = 3;
+  PeerDescriptor peerDescriptor = 2;
 }
 
 message HandshakeResponse {
   bytes sourceId = 1;
-  string protocolVersion = 2;
-  PeerDescriptor peerDescriptor = 3;
-  optional string responseError = 4;
+  PeerDescriptor peerDescriptor = 2;
+  optional string responseError = 3;
 }
 
 // Wraps all messages
@@ -237,7 +228,7 @@ message Message {
     HandshakeRequest handshakeRequest = 8;
     HandshakeResponse handshakeResponse = 9;
     protorpc.RpcMessage rpcMessage = 10;
-    RecursiveFindRequest RecursiveFindRequest = 11;
+    FindRequest findRequest = 11;
   };
 }
 
@@ -245,58 +236,42 @@ message Message {
 
 // WebSocket
 message WebSocketConnectionRequest {
-  PeerDescriptor requester = 1;
-  PeerDescriptor target = 2;
-  string ip = 3;
-  uint32 port = 4;
+  string ip = 1;
+  uint32 port = 2;
 }
 
 message WebSocketConnectionResponse {
-  PeerDescriptor requester = 1;
-  PeerDescriptor target = 2;
-  bool accepted = 3;
-  optional string reason = 4;
+  bool accepted = 1;
+  optional string reason = 2;
 }
 
 // WebRTC
 message WebRtcConnectionRequest {
-  PeerDescriptor requester = 1;
-  PeerDescriptor target = 2;
-  string connectionId = 3;
+  string connectionId = 1;
 }
 
 message RtcOffer {
-  PeerDescriptor requester = 1;
-  PeerDescriptor target = 2;
-  string description = 3;
-  string connectionId = 4;
+  string description = 1;
+  string connectionId = 2;
 }
 
 message RtcAnswer {
-  PeerDescriptor requester = 1;
-  PeerDescriptor target = 2;
-  string description = 3;
-  string connectionId = 4;
+  string description = 1;
+  string connectionId = 2;
 }
 
 message IceCandidate {
   string candidate = 1;
   string mid = 2;
   string connectionId = 3;
-  PeerDescriptor requester = 4;
-  PeerDescriptor target = 5;
 }
 
 message LockRequest {
-  string protocolVersion = 1;
-  PeerDescriptor peerDescriptor = 2;
-  string serviceId = 3;
+  string serviceId = 1;
 }
 
 message UnlockRequest {
-  string protocolVersion = 1;
-  PeerDescriptor peerDescriptor = 2;
-  string serviceId = 3;
+  string serviceId = 1;
 }
 
 message LockResponse {
@@ -310,18 +285,14 @@ enum DisconnectMode {
 }
 
 message DisconnectNotice {
-  string protocolVersion = 1;
-  PeerDescriptor peerDescriptor = 2;
-  DisconnectMode disconnecMode = 3;
+  DisconnectMode disconnectMode = 1;
 }
 
 message DisconnectNoticeResponse {
-  string protocolVersion = 1;
 }
 
 message FindDataRequest {
   bytes kademliaId = 1;
-  PeerDescriptor requestor = 2;
 }
 
 message FindDataResponse {

package/src/connection/ConnectionLockRpcRemote.ts

@@ -0,0 +1,62 @@
+import { Logger } from '@streamr/utils'
+import { ProtoRpcClient } from '@streamr/proto-rpc'
+import { IConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { LockRequest, UnlockRequest, PeerDescriptor, DisconnectNotice, DisconnectMode } from '../proto/packages/dht/protos/DhtRpc'
+
+import * as Err from '../helpers/errors'
+import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { Remote } from '../dht/contact/Remote'
+
+const logger = new Logger(module)
+
+export class ConnectionLockRpcRemote extends Remote<IConnectionLockRpcClient> {
+
+    constructor(
+        ownPeerDescriptor: PeerDescriptor,
+        targetPeerDescriptor: PeerDescriptor,
+        client: ProtoRpcClient<IConnectionLockRpcClient>
+    ) {
+        super(ownPeerDescriptor, targetPeerDescriptor, 'DUMMY', client)
+    }
+
+    public async lockRequest(serviceId: string): Promise<boolean> {
+        logger.trace(`Requesting locked connection to ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        const request: LockRequest = {
+            serviceId
+        }
+        const options = this.formDhtRpcOptions()
+        try {
+            const res = await this.getClient().lockRequest(request, options)
+            return res.accepted
+        } catch (err) {
+            logger.debug(new Err.ConnectionLocker('Connection lock rejected', err).stack!)
+            return false
+        }
+    }
+
+    public unlockRequest(serviceId: string): void {
+        logger.trace(`Requesting connection to be unlocked from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        const request: UnlockRequest = {
+            serviceId
+        }
+        const options = this.formDhtRpcOptions({
+            notification: true
+        })
+        this.getClient().unlockRequest(request, options).catch((_e) => {
+            logger.trace('failed to send unlockRequest')
+        })
+    }
+
+    public async gracefulDisconnect(disconnectMode: DisconnectMode): Promise<void> {
+        logger.trace(`Notifying a graceful disconnect to ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        const request: DisconnectNotice = {
+            disconnectMode
+        }
+        const options = this.formDhtRpcOptions({
+            doNotConnect: true,
+            doNotMindStopped: true,
+            timeout: 2000
+        })
+        await this.getClient().gracefulDisconnect(request, options)
+    }
+}

package/src/connection/ConnectionManager.ts

@@ -24,14 +24,16 @@ import {
     PeerDescriptor,
     UnlockRequest
 } from '../proto/packages/dht/protos/DhtRpc'
-import { ConnectionLockerClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { DisconnectionType, ITransport, TransportEvents } from '../transport/ITransport'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
 import { ConnectionLockHandler } from './ConnectionLockHandler'
 import { ConnectorFacade } from './ConnectorFacade'
 import { ManagedConnection, Events as ManagedConnectionEvents } from './ManagedConnection'
-import { RemoteConnectionLocker } from './RemoteConnectionLocker'
+import { ConnectionLockRpcRemote } from './ConnectionLockRpcRemote'
 import { WEB_RTC_CLEANUP } from './WebRTC/NodeWebRtcConnection'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 
 export interface ConnectionManagerConfig {
     maxConnections?: number
@@ -109,7 +111,6 @@ export const keyOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor |
 
 export class ConnectionManager extends EventEmitter<Events> implements ITransport, ConnectionLocker {
 
-    public static PROTOCOL_VERSION = '1.0'
     private config: ConnectionManagerConfig
     private readonly metricsContext: MetricsContext
     private readonly duplicateMessageDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
@@ -142,11 +143,11 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             rpcRequestTimeout: 10000
         })
         this.rpcCommunicator.registerRpcMethod(LockRequest, LockResponse, 'lockRequest',
-            (req: LockRequest) => this.lockRequest(req))
+            (req: LockRequest, context: ServerCallContext) => this.lockRequest(req, context))
         this.rpcCommunicator.registerRpcNotification(UnlockRequest, 'unlockRequest',
-            (req: UnlockRequest) => this.unlockRequest(req))
+            (req: UnlockRequest, context: ServerCallContext) => this.unlockRequest(req, context))
         this.rpcCommunicator.registerRpcMethod(DisconnectNotice, DisconnectNoticeResponse, 'gracefulDisconnect',
-            (req: DisconnectNotice) => this.gracefulDisconnect(req))
+            (req: DisconnectNotice, context: ServerCallContext) => this.gracefulDisconnect(req, context))
     }
 
     public garbageCollectConnections(maxConnections: number, lastUsedLimit: number): void {
@@ -464,14 +465,13 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             return
         }
         const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        const remoteConnectionLocker = new RemoteConnectionLocker(
+        const rpcRemote = new ConnectionLockRpcRemote(
             this.getOwnPeerDescriptor(),
             targetDescriptor,
-            ConnectionManager.PROTOCOL_VERSION,
-            toProtoRpcClient(new ConnectionLockerClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
         this.locks.addLocalLocked(peerIdKey, serviceId)
-        remoteConnectionLocker.lockRequest(serviceId)
+        rpcRemote.lockRequest(serviceId)
             .then((_accepted) => logger.trace('LockRequest successful'))
             .catch((err) => { logger.debug(err) })
     }
@@ -482,14 +482,13 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         }
         const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
         this.locks.removeLocalLocked(peerIdKey, serviceId)
-        const remoteConnectionLocker = new RemoteConnectionLocker(
+        const rpcRemote = new ConnectionLockRpcRemote(
             this.getOwnPeerDescriptor(),
             targetDescriptor,
-            ConnectionManager.PROTOCOL_VERSION,
-            toProtoRpcClient(new ConnectionLockerClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
         if (this.connections.has(peerIdKey)) {
-            remoteConnectionLocker.unlockRequest(serviceId)
+            rpcRemote.unlockRequest(serviceId)
         }
     }
 
@@ -546,16 +545,15 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
 
     private async doGracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
         logger.trace(keyFromPeerDescriptor(targetDescriptor) + ' gracefullyDisconnectAsync()')
-        const remoteConnectionLocker = new RemoteConnectionLocker(
+        const rpcRemote = new ConnectionLockRpcRemote(
             this.getOwnPeerDescriptor(),
             targetDescriptor,
-            ConnectionManager.PROTOCOL_VERSION,
-            toProtoRpcClient(new ConnectionLockerClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
         try {
-            await remoteConnectionLocker.gracefulDisconnect(disconnectMode)
+            await rpcRemote.gracefulDisconnect(disconnectMode)
         } catch (ex) {
-            logger.trace(keyFromPeerDescriptor(targetDescriptor) + ' remoteConnectionLocker.gracefulDisconnect() failed' + ex)
+            logger.trace(keyFromPeerDescriptor(targetDescriptor) + ' remote.gracefulDisconnect() failed' + ex)
         }
     }
 
@@ -565,10 +563,11 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
             .map((managedConnection: ManagedConnection) => managedConnection.getPeerDescriptor()!)
     }
 
-    // IConnectionLocker server implementation
-    private async lockRequest(lockRequest: LockRequest): Promise<LockResponse> {
-        const remotePeerId = peerIdFromPeerDescriptor(lockRequest.peerDescriptor!)
-        if (areEqualPeerDescriptors(lockRequest.peerDescriptor!, this.getOwnPeerDescriptor())) {
+    // ConnectionLockRpc local RPC method
+    private async lockRequest(lockRequest: LockRequest, context: ServerCallContext): Promise<LockResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const remotePeerId = peerIdFromPeerDescriptor(senderPeerDescriptor)
+        if (areEqualPeerDescriptors(senderPeerDescriptor, this.getOwnPeerDescriptor())) {
             const response: LockResponse = {
                 accepted: false
             }
@@ -581,21 +580,23 @@ export class ConnectionManager extends EventEmitter<Events> implements ITranspor
         return response
     }
 
-    // IConnectionLocker server implementation
-    private async unlockRequest(unlockRequest: UnlockRequest): Promise<Empty> {
-        const peerIdKey = keyFromPeerDescriptor(unlockRequest.peerDescriptor!)
+    // ConnectionLockRpc local RPC method
+    private async unlockRequest(unlockRequest: UnlockRequest, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const peerIdKey = keyFromPeerDescriptor(senderPeerDescriptor)
         this.locks.removeRemoteLocked(peerIdKey, unlockRequest.serviceId)
         return {}
     }
 
-    // IConnectionLocker server implementation
-    private async gracefulDisconnect(disconnectNotice: DisconnectNotice): Promise<Empty> {
-        logger.trace(keyOrUnknownFromPeerDescriptor(disconnectNotice.peerDescriptor) + ' received gracefulDisconnect notice')
+    // ConnectionLockRpc local RPC method
+    private async gracefulDisconnect(disconnectNotice: DisconnectNotice, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        logger.trace(keyOrUnknownFromPeerDescriptor(senderPeerDescriptor) + ' received gracefulDisconnect notice')
 
-        if (disconnectNotice.disconnecMode === DisconnectMode.LEAVING) {
-            this.closeConnection(disconnectNotice.peerDescriptor!, 'INCOMING_GRACEFUL_LEAVE', 'graceful leave notified')
+        if (disconnectNotice.disconnectMode === DisconnectMode.LEAVING) {
+            this.closeConnection(senderPeerDescriptor, 'INCOMING_GRACEFUL_LEAVE', 'graceful leave notified')
         } else {
-            this.closeConnection(disconnectNotice.peerDescriptor!, 'INCOMING_GRACEFUL_DISCONNECT', 'graceful disconnect notified')
+            this.closeConnection(senderPeerDescriptor, 'INCOMING_GRACEFUL_DISCONNECT', 'graceful disconnect notified')
         }
         return {}
     }

package/src/connection/ConnectivityChecker.ts

@@ -10,7 +10,7 @@ import { ClientWebSocket } from './WebSocket/ClientWebSocket'
 import { v4 } from 'uuid'
 import { NatType } from './ConnectionManager'
 import { ServerWebSocket } from './WebSocket/ServerWebSocket'
-import { connectivityMethodToWebSocketUrl } from './WebSocket/WebSocketConnector'
+import { connectivityMethodToWebSocketUrl } from './WebSocket/WebSocketConnectorRpcLocal'
 
 const logger = new Logger(module)
 

package/src/connection/ConnectorFacade.ts

@@ -4,12 +4,12 @@ import {
     PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ITransport } from '../transport/ITransport'
-import { ConnectionManager, PortRange, TlsCertificate } from './ConnectionManager'
+import { PortRange, TlsCertificate } from './ConnectionManager'
 import { ManagedConnection } from './ManagedConnection'
 import { Simulator } from './Simulator/Simulator'
 import { SimulatorConnector } from './Simulator/SimulatorConnector'
-import { IceServer, WebRtcConnector } from './WebRTC/WebRtcConnector'
-import { WebSocketConnector } from './WebSocket/WebSocketConnector'
+import { IceServer, WebRtcConnectorRpcLocal } from './WebRTC/WebRtcConnectorRpcLocal'
+import { WebSocketConnectorRpcLocal } from './WebSocket/WebSocketConnectorRpcLocal'
 
 export interface ConnectorFacade {
     createConnection: (peerDescriptor: PeerDescriptor) => ManagedConnection
@@ -44,8 +44,8 @@ export class DefaultConnectorFacade implements ConnectorFacade {
 
     private readonly config: DefaultConnectorFacadeConfig
     private ownPeerDescriptor?: PeerDescriptor
-    private webSocketConnector?: WebSocketConnector
-    private webrtcConnector?: WebRtcConnector
+    private webSocketConnector?: WebSocketConnectorRpcLocal
+    private webrtcConnector?: WebRtcConnectorRpcLocal
 
     constructor(config: DefaultConnectorFacadeConfig) {
         this.config = config
@@ -56,8 +56,7 @@ export class DefaultConnectorFacade implements ConnectorFacade {
         canConnect: (peerDescriptor: PeerDescriptor) => boolean
     ): Promise<void> {
         logger.trace(`Creating WebSocketConnector`)
-        this.webSocketConnector = new WebSocketConnector({
-            protocolVersion: ConnectionManager.PROTOCOL_VERSION,
+        this.webSocketConnector = new WebSocketConnectorRpcLocal({
             transport: this.config.transport!,
             // TODO should we use canConnect also for WebRtcConnector? (NET-1142)
             canConnect: (peerDescriptor: PeerDescriptor) => canConnect(peerDescriptor),
@@ -69,9 +68,8 @@ export class DefaultConnectorFacade implements ConnectorFacade {
             maxMessageSize: this.config.maxMessageSize
         })
         logger.trace(`Creating WebRTCConnector`)
-        this.webrtcConnector = new WebRtcConnector({
+        this.webrtcConnector = new WebRtcConnectorRpcLocal({
             transport: this.config.transport!,
-            protocolVersion: ConnectionManager.PROTOCOL_VERSION,
             iceServers: this.config.iceServers,
             allowPrivateAddresses: this.config.webrtcAllowPrivateAddresses,
             bufferThresholdLow: this.config.webrtcDatachannelBufferThresholdLow,
@@ -121,7 +119,6 @@ export class SimulatorConnectorFacade implements ConnectorFacade {
     async start(onIncomingConnection: (connection: ManagedConnection) => boolean): Promise<void> {
         logger.trace(`Creating SimulatorConnector`)
         this.simulatorConnector = new SimulatorConnector(
-            ConnectionManager.PROTOCOL_VERSION,
             this.ownPeerDescriptor,
             this.simulator,
             onIncomingConnection

package/src/connection/Handshaker.ts

@@ -16,17 +16,14 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
 
     private static readonly HANDSHAKER_SERVICE_ID = 'system/handshaker'
     private ownPeerDescriptor: PeerDescriptor
-    private protocolVersion: string
     private connection: IConnection
 
     constructor(
         ownPeerDescriptor: PeerDescriptor,
-        protocolVersion: string, 
         connection: IConnection
     ) {
         super()
         this.ownPeerDescriptor = ownPeerDescriptor
-        this.protocolVersion = protocolVersion
         this.connection = connection
         this.connection.on('data', this.onData)
     }
@@ -57,7 +54,6 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     public sendHandshakeRequest(): void {
         const outgoingHandshake: HandshakeRequest = {
             sourceId: this.ownPeerDescriptor.kademliaId,
-            protocolVersion: this.protocolVersion,
             peerDescriptor: this.ownPeerDescriptor
         }
         const msg: Message = {
@@ -76,7 +72,6 @@ export class Handshaker extends EventEmitter<HandshakerEvents> {
     public sendHandshakeResponse(error?: string): void {
         const outgoingHandshakeResponse: HandshakeResponse = {
             sourceId: this.ownPeerDescriptor.kademliaId,
-            protocolVersion: this.protocolVersion,
             peerDescriptor: this.ownPeerDescriptor
         }
         if (error) {

package/src/connection/ManagedConnection.ts

@@ -45,13 +45,11 @@ export class ManagedConnection extends EventEmitter<Events> {
     private closing = false
     public replacedByOtherConnection = false
     private ownPeerDescriptor: PeerDescriptor
-    private protocolVersion: string
     protected outgoingConnection?: IConnection
     protected incomingConnection?: IConnection
 
     constructor(
         ownPeerDescriptor: PeerDescriptor,
-        protocolVersion: string,
         connectionType: ConnectionType,
         outgoingConnection?: IConnection,
         incomingConnection?: IConnection,
@@ -61,7 +59,6 @@ export class ManagedConnection extends EventEmitter<Events> {
         this.send = this.send.bind(this)
 
         this.ownPeerDescriptor = ownPeerDescriptor
-        this.protocolVersion = protocolVersion
         this.outgoingConnection = outgoingConnection
         this.incomingConnection = incomingConnection
         this.connectionType = connectionType
@@ -75,7 +72,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         }
 
         if (outgoingConnection) {
-            this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, outgoingConnection)
+            this.handshaker = new Handshaker(this.ownPeerDescriptor, outgoingConnection)
 
             this.handshaker.once('handshakeFailed', (errorMessage) => {
                 logger.trace(keyOrUnknownFromPeerDescriptor(this.peerDescriptor) + ' handshakeFailed: ' + errorMessage)
@@ -98,7 +95,7 @@ export class ManagedConnection extends EventEmitter<Events> {
 
         } else {
             if (incomingConnection) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, incomingConnection)
+                this.handshaker = new Handshaker(this.ownPeerDescriptor, incomingConnection)
                 this.handshaker.on('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
                     this.setPeerDescriptor(peerDescriptor)
                     this.emit('handshakeRequest', peerDescriptor)
@@ -308,7 +305,7 @@ export class ManagedConnection extends EventEmitter<Events> {
         // This happens when connectionRequest has been made and answered
         if (this.implementation) {
             if (!this.handshaker) {
-                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.protocolVersion, this.implementation)
+                this.handshaker = new Handshaker(this.ownPeerDescriptor, this.implementation)
             }
 
             this.handshaker.sendHandshakeResponse()

package/src/connection/ManagedWebRtcConnection.ts

@@ -6,12 +6,10 @@ import { NodeWebRtcConnection } from './WebRTC/NodeWebRtcConnection'
 export class ManagedWebRtcConnection extends ManagedConnection {
 
     constructor(ownPeerDescriptor: PeerDescriptor,
-        protocolVersion: string,
         connectingConnection?: NodeWebRtcConnection,
         connectedConnection?: NodeWebRtcConnection) {
         super(
             ownPeerDescriptor,
-            protocolVersion,
             ConnectionType.WEBRTC,
             connectingConnection,
             connectedConnection)

package/src/connection/Simulator/SimulatorConnector.ts

@@ -16,18 +16,15 @@ export class SimulatorConnector {
 
     private connectingConnections: Map<PeerIDKey, ManagedConnection> = new Map()
     private stopped = false
-    private protocolVersion: string
     private ownPeerDescriptor: PeerDescriptor
     private simulator: Simulator
     private onIncomingConnection: (connection: ManagedConnection) => boolean
 
     constructor(
-        protocolVersion: string,
         ownPeerDescriptor: PeerDescriptor,
         simulator: Simulator,
         onIncomingConnection: (connection: ManagedConnection) => boolean
     ) {
-        this.protocolVersion = protocolVersion
         this.ownPeerDescriptor = ownPeerDescriptor
         this.simulator = simulator
         this.onIncomingConnection = onIncomingConnection
@@ -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)
@@ -72,8 +68,7 @@ export class SimulatorConnector {
         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')
 

package/src/connection/WebRTC/NodeWebRtcConnection.ts

@@ -8,7 +8,7 @@ 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)