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

package/protos/DhtRpc.proto

@@ -19,8 +19,8 @@ service RouterRpc {
   rpc forwardMessage (RouteMessageWrapper) returns (RouteMessageAck);
 }
 
-service FindRpc {
-  rpc routeFindRequest (RouteMessageWrapper) returns (RouteMessageAck);
+service RecursiveOperationRpc {
+  rpc routeRequest (RouteMessageWrapper) returns (RouteMessageAck);
 }
 
 service StoreRpc {
@@ -28,12 +28,12 @@ service StoreRpc {
   rpc replicateData (ReplicateDataRequest) returns (google.protobuf.Empty);
 }
 
-service FindSessionRpc {
-  rpc sendFindResponse(FindResponse) returns (google.protobuf.Empty);
+service RecursiveOperationSessionRpc {
+  rpc sendResponse(RecursiveOperationResponse) returns (google.protobuf.Empty);
 }
 
 service WebsocketConnectorRpc {
-  rpc requestConnection (WebsocketConnectionRequest) returns (WebsocketConnectionResponse);
+  rpc requestConnection (WebsocketConnectionRequest) returns (google.protobuf.Empty);
 }
 
 service WebrtcConnectorRpc {
@@ -59,13 +59,12 @@ service ExternalApiRpc {
 message StoreDataRequest {
   bytes key = 1;
   google.protobuf.Any data = 2;
-  PeerDescriptor creator = 3;
+  bytes creator = 3;
   google.protobuf.Timestamp createdAt = 4;
   uint32 ttl = 5;
 }
 
 message StoreDataResponse {
-  string error = 1;
 }
 
 message ExternalStoreDataRequest {
@@ -84,7 +83,7 @@ message ReplicateDataRequest {
 message DataEntry {
   bytes key = 1;
   google.protobuf.Any data = 2;
-  PeerDescriptor creator = 3;
+  bytes creator = 3;
   google.protobuf.Timestamp createdAt = 4;
   google.protobuf.Timestamp storedAt = 5; 
   uint32 ttl = 6;   // milliseconds
@@ -102,18 +101,18 @@ message ClosestPeersResponse {
   string requestId = 2;
 }
 
-message FindRequest {
+message RecursiveOperationRequest {
   string sessionId = 1;
-  FindAction action = 2;
+  RecursiveOperation operation = 2;
 }
 
-enum FindAction {
-  NODE = 0;
+enum RecursiveOperation {
+  FIND_NODE = 0;
   FETCH_DATA = 1;
   DELETE_DATA = 2;
 }
 
-message FindResponse {
+message RecursiveOperationResponse {
   repeated PeerDescriptor closestConnectedPeers = 1;
   repeated DataEntry dataEntries = 2;
   bool noCloserNodesFound = 3;
@@ -150,7 +149,6 @@ message ConnectivityMethod {
 enum NodeType {
   NODEJS = 0;
   BROWSER = 1;
-  VIRTUAL = 3;
 }
 
 enum RpcResponseError {
@@ -161,9 +159,9 @@ enum RpcResponseError {
 }
 
 message RouteMessageWrapper {
-  PeerDescriptor sourcePeer = 1;
-  string requestId = 2;
-  PeerDescriptor destinationPeer = 3;
+  string requestId = 1;
+  PeerDescriptor sourcePeer = 2;
+  bytes target = 3;
   Message message = 4;
   repeated PeerDescriptor reachableThrough = 5;
   repeated PeerDescriptor routingPath = 6;
@@ -220,7 +218,7 @@ enum MessageType {
   CONNECTIVITY_RESPONSE = 2;
   HANDSHAKE_REQUEST = 3;
   HANDSHAKE_RESPONSE = 4;
-  FIND_REQUEST = 5;
+  RECURSIVE_OPERATION_REQUEST = 5;
 }
 
 message Message {
@@ -235,7 +233,7 @@ message Message {
     HandshakeRequest handshakeRequest = 8;
     HandshakeResponse handshakeResponse = 9;
     protorpc.RpcMessage rpcMessage = 10;
-    FindRequest findRequest = 11;
+    RecursiveOperationRequest recursiveOperationRequest = 11;
   };
 }
 
@@ -245,10 +243,6 @@ message Message {
 message WebsocketConnectionRequest {
 }
 
-message WebsocketConnectionResponse {
-  bool accepted = 1;
-}
-
 // WebRTC
 message WebrtcConnectionRequest {
 }

package/src/connection/ConnectionLockHandler.ts

@@ -1,17 +1,17 @@
 // Connection locks are independent of the existence of connections
 // that is why this class is needed
 
-import { PeerIDKey } from '../helpers/PeerID'
+import { NodeID } from '../helpers/nodeId'
 
 export type LockID = string
 
 export class ConnectionLockHandler {
 
-    private localLocks: Map<PeerIDKey, Set<LockID>> = new Map()
-    private remoteLocks: Map<PeerIDKey, Set<LockID>> = new Map()
+    private localLocks: Map<NodeID, Set<LockID>> = new Map()
+    private remoteLocks: Map<NodeID, Set<LockID>> = new Map()
     // TODO: remove weakLocks use localLocks instead. When opening weakLocks from the ConnectioManager,
     // simply do not send lock requests.
-    private weakLocks: Set<PeerIDKey> = new Set()
+    private weakLocks: Set<NodeID> = new Set()
 
     public getNumberOfLocalLockedConnections(): number {
         return this.localLocks.size
@@ -25,7 +25,7 @@ export class ConnectionLockHandler {
         return this.weakLocks.size
     }
 
-    public isLocalLocked(id: PeerIDKey, lockId?: LockID): boolean {
+    public isLocalLocked(id: NodeID, lockId?: LockID): boolean {
         if (lockId === undefined) {
             return this.localLocks.has(id)
         } else {
@@ -33,7 +33,7 @@ export class ConnectionLockHandler {
         }
     }
 
-    public isRemoteLocked(id: PeerIDKey, lockId?: LockID): boolean {
+    public isRemoteLocked(id: NodeID, lockId?: LockID): boolean {
         if (lockId === undefined) {
             return this.remoteLocks.has(id)
         } else {
@@ -45,33 +45,33 @@ export class ConnectionLockHandler {
         }
     }
 
-    private isWeakLocked(id: PeerIDKey): boolean {
+    private isWeakLocked(id: NodeID): boolean {
         return this.weakLocks.has(id)
     }
 
-    public isLocked(id: PeerIDKey): boolean {
+    public isLocked(id: NodeID): boolean {
         return (this.isLocalLocked(id) || this.isRemoteLocked(id) || this.isWeakLocked(id))
     }
 
-    public addLocalLocked(id: PeerIDKey, lockId: LockID): void {
+    public addLocalLocked(id: NodeID, lockId: LockID): void {
         if (!this.localLocks.has(id)) {
             this.localLocks.set(id, new Set())
         }
         this.localLocks.get(id)!.add(lockId)
     }
 
-    public addRemoteLocked(id: PeerIDKey, lockId: LockID): void {
+    public addRemoteLocked(id: NodeID, lockId: LockID): void {
         if (!this.remoteLocks.has(id)) {
             this.remoteLocks.set(id, new Set())
         }
         this.remoteLocks.get(id)!.add(lockId)
     }
 
-    public addWeakLocked(id: PeerIDKey): void {
+    public addWeakLocked(id: NodeID): void {
         this.weakLocks.add(id)
     }
 
-    public removeLocalLocked(id: PeerIDKey, lockId: LockID): void {
+    public removeLocalLocked(id: NodeID, lockId: LockID): void {
         if (this.localLocks.has(id)) {
             this.localLocks.get(id)?.delete(lockId)
             if (this.localLocks.get(id)?.size === 0) {
@@ -80,7 +80,7 @@ export class ConnectionLockHandler {
         }
     }
 
-    public removeRemoteLocked(id: PeerIDKey, lockId: LockID): void {
+    public removeRemoteLocked(id: NodeID, lockId: LockID): void {
         if (this.remoteLocks.has(id)) {
             this.remoteLocks.get(id)?.delete(lockId)
             if (this.remoteLocks.get(id)?.size === 0) {
@@ -89,11 +89,11 @@ export class ConnectionLockHandler {
         }
     }
 
-    public removeWeakLocked(id: PeerIDKey): void {
+    public removeWeakLocked(id: NodeID): void {
         this.weakLocks.delete(id)
     }
 
-    public clearAllLocks(id: PeerIDKey): void {
+    public clearAllLocks(id: NodeID): void {
         this.localLocks.delete(id)
         this.remoteLocks.delete(id)
         this.weakLocks.delete(id)

package/src/connection/ConnectionLockRpcLocal.ts

@@ -2,8 +2,7 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
 import {
     areEqualPeerDescriptors,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor
 } from '../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
@@ -16,13 +15,13 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import { IConnectionLockRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { PeerIDKey } from '../helpers/PeerID'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
 import { LockID } from './ConnectionLockHandler'
+import { NodeID } from '../helpers/nodeId'
 
 interface ConnectionLockRpcLocalConfig {
-    addRemoteLocked: (id: PeerIDKey, lockId: LockID) => void
-    removeRemoteLocked: (id: PeerIDKey, lockId: LockID) => void
+    addRemoteLocked: (id: NodeID, lockId: LockID) => void
+    removeRemoteLocked: (id: NodeID, lockId: LockID) => void
     closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => void
     getLocalPeerDescriptor: () => PeerDescriptor
 }
@@ -39,14 +38,14 @@ export class ConnectionLockRpcLocal implements IConnectionLockRpc {
 
     async lockRequest(lockRequest: LockRequest, context: ServerCallContext): Promise<LockResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remotePeerId = peerIdFromPeerDescriptor(senderPeerDescriptor)
         if (areEqualPeerDescriptors(senderPeerDescriptor, this.config.getLocalPeerDescriptor())) {
             const response: LockResponse = {
                 accepted: false
             }
             return response
         }
-        this.config.addRemoteLocked(remotePeerId.toKey(), lockRequest.lockId)
+        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        this.config.addRemoteLocked(remoteNodeId, lockRequest.lockId)
         const response: LockResponse = {
             accepted: true
         }
@@ -55,8 +54,8 @@ export class ConnectionLockRpcLocal implements IConnectionLockRpc {
 
     async unlockRequest(unlockRequest: UnlockRequest, context: ServerCallContext): Promise<Empty> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const peerIdKey = keyFromPeerDescriptor(senderPeerDescriptor)
-        this.config.removeRemoteLocked(peerIdKey, unlockRequest.lockId)
+        const nodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        this.config.removeRemoteLocked(nodeId, unlockRequest.lockId)
         return {}
     }
 

package/src/connection/ConnectionLockRpcRemote.ts

@@ -1,22 +1,13 @@
 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 { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { RpcRemote } from '../dht/contact/RpcRemote'
+import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { DisconnectMode, DisconnectNotice, LockRequest, UnlockRequest } from '../proto/packages/dht/protos/DhtRpc'
+import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { LockID } from './ConnectionLockHandler'
 
 const logger = new Logger(module)
 
-export class ConnectionLockRpcRemote extends RpcRemote<IConnectionLockRpcClient> {
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        targetPeerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IConnectionLockRpcClient>
-    ) {
-        super(localPeerDescriptor, targetPeerDescriptor, 'DUMMY', client)
-    }
+export class ConnectionLockRpcRemote extends RpcRemote<ConnectionLockRpcClient> {
 
     public async lockRequest(lockId: LockID): Promise<boolean> {
         logger.trace(`Requesting locked connection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
@@ -52,9 +43,9 @@ export class ConnectionLockRpcRemote extends RpcRemote<IConnectionLockRpcClient>
             disconnectMode
         }
         const options = this.formDhtRpcOptions({
-            doNotConnect: true,
-            doNotMindStopped: true,
-            timeout: 2000
+            connect: false,
+            sendIfStopped: true,
+            timeout: 2000  // TODO use config option or named constant?
         })
         await this.getClient().gracefulDisconnect(request, options)
     }

package/src/connection/ConnectionManager.ts

@@ -1,15 +1,12 @@
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { CountMetric, LevelMetric, Logger, Metric, MetricsContext, MetricsDefinition, RateMetric, waitForEvent3 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { Contact } from '../dht/contact/Contact'
 import { SortedContactList } from '../dht/contact/SortedContactList'
 import { DuplicateDetector } from '../dht/routing/DuplicateDetector'
-import { PeerIDKey } from '../helpers/PeerID'
 import * as Err from '../helpers/errors'
 import {
     areEqualPeerDescriptors,
     getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../helpers/peerIdFromPeerDescriptor'
 import { protoToString } from '../helpers/protoToString'
@@ -25,7 +22,7 @@ import {
     UnlockRequest
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
-import { ITransport, TransportEvents } from '../transport/ITransport'
+import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../transport/ITransport'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
 import { ConnectionLockHandler, LockID } from './ConnectionLockHandler'
 import { ConnectorFacade } from './ConnectorFacade'
@@ -34,6 +31,7 @@ import { ConnectionLockRpcRemote } from './ConnectionLockRpcRemote'
 import { WEBRTC_CLEANUP } from './webrtc/NodeWebrtcConnection'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ConnectionLockRpcLocal } from './ConnectionLockRpcLocal'
+import { NodeID } from '../helpers/nodeId'
 
 export interface ConnectionManagerConfig {
     maxConnections?: number
@@ -55,9 +53,6 @@ interface ConnectionManagerMetrics extends MetricsDefinition {
     connectionTotalFailureCount: Metric
 }
 
-// TODO move this type identifiers.ts and use also in other classes (and rename to ServiceID)
-type ServiceId = string
-
 const logger = new Logger(module)
 
 enum ConnectionManagerState {
@@ -68,8 +63,8 @@ enum ConnectionManagerState {
 }
 
 export interface ConnectionLocker {
-    lockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void
-    unlockConnection(targetDescriptor: PeerDescriptor, serviceId: ServiceId): void
+    lockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void
+    unlockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void
     weakLockConnection(targetDescriptor: PeerDescriptor): void
     weakUnlockConnection(targetDescriptor: PeerDescriptor): void
 }
@@ -107,10 +102,11 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
 
     private config: ConnectionManagerConfig
     private readonly metricsContext: MetricsContext
+    // TODO use config option or named constant?
     private readonly duplicateMessageDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
     private readonly metrics: ConnectionManagerMetrics
     private locks = new ConnectionLockHandler()
-    private connections: Map<PeerIDKey, ManagedConnection> = new Map()
+    private connections: Map<NodeID, ManagedConnection> = new Map()
     private readonly connectorFacade: ConnectorFacade
     private rpcCommunicator?: RoutingRpcCommunicator
     private disconnectorIntervalRef?: NodeJS.Timeout
@@ -135,11 +131,11 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         this.connectorFacade = this.config.createConnectorFacade()
         this.send = this.send.bind(this)
         this.rpcCommunicator = new RoutingRpcCommunicator(INTERNAL_SERVICE_ID, this.send, {
-            rpcRequestTimeout: 10000
+            rpcRequestTimeout: 10000  // TODO use config option or named constant?
         })
         const lockRpcLocal = new ConnectionLockRpcLocal({
-            addRemoteLocked: (id: PeerIDKey, serviceId: string) => this.locks.addRemoteLocked(id, serviceId),
-            removeRemoteLocked: (id: PeerIDKey, serviceId: string) => this.locks.removeRemoteLocked(id, serviceId),
+            addRemoteLocked: (id: NodeID, lockId: LockID) => this.locks.addRemoteLocked(id, lockId),
+            removeRemoteLocked: (id: NodeID, lockId: LockID) => this.locks.removeRemoteLocked(id, lockId),
             closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => {
                 // TODO should we have some handling for this floating promise?
                 this.closeConnection(peerDescriptor, gracefulLeave, reason)
@@ -159,13 +155,13 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return
         }
         const disconnectionCandidates = new SortedContactList<Contact>({
-            referenceId: peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 
+            referenceId: getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 
             maxSize: 100000,  // TODO use config option or named constant?
             allowToContainReferenceId: false,
             emitEvents: false
         })
         this.connections.forEach((connection) => {
-            if (!this.locks.isLocked(connection.peerIdKey) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
+            if (!this.locks.isLocked(connection.getNodeId()) && Date.now() - connection.getLastUsed() > lastUsedLimit) {
                 logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
                 disconnectionCandidates.addContact(new Contact(connection.getPeerDescriptor()!))
             }
@@ -187,6 +183,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         logger.trace(`Starting ConnectionManager...`)
         await this.connectorFacade.start(
             (connection: ManagedConnection) => this.onNewConnection(connection),
+            (peerDescriptor: PeerDescriptor) => this.hasConnection(peerDescriptor),
             this
         )
         // Garbage collection of connections
@@ -194,7 +191,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             logger.trace('disconnectorInterval')
             const LAST_USED_LIMIT = 20000
             this.garbageCollectConnections(this.config.maxConnections ?? 80, LAST_USED_LIMIT)
-        }, 5000)
+        }, 5000)  // TODO use config option or named constant?
     }
 
     public async stop(): Promise<void> {
@@ -217,6 +214,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
                 }
             } else {
                 logger.trace('handshake of connection not completed, force-closing')
+                // TODO use config option or named constant?
                 const eventReceived = waitForEvent3<ManagedConnectionEvents>(peer, 'disconnected', 2000)
                 // TODO should we have some handling for this floating promise?
                 peer.close(true)
@@ -252,8 +250,8 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         return this.locks.getNumberOfWeakLockedConnections()
     }
 
-    public async send(message: Message, doNotConnect = false, doNotMindStopped = false): Promise<void> {
-        if (this.state === ConnectionManagerState.STOPPED && !doNotMindStopped) {
+    public async send(message: Message, opts: SendOptions = DEFAULT_SEND_OPTIONS): Promise<void> {
+        if (this.state === ConnectionManagerState.STOPPED && !opts.sendIfStopped) {
             return
         }
         const peerDescriptor = message.targetDescriptor!
@@ -265,18 +263,18 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             ...message,
             sourceDescriptor: this.getLocalPeerDescriptor()
         }
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        let connection = this.connections.get(peerIdKey)
-        if (!connection && !doNotConnect) {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        let connection = this.connections.get(nodeId)
+        if (!connection && opts.connect) {
             connection = this.connectorFacade.createConnection(peerDescriptor)
             this.onNewConnection(connection)
         } else if (!connection) {
-            throw new Err.SendFailed('No connection to target, doNotConnect flag is true')
+            throw new Err.SendFailed('No connection to target, connect flag is false')
         }
         const binary = Message.toBinary(message)
         this.metrics.sendBytesPerSecond.record(binary.byteLength)
         this.metrics.sendMessagesPerSecond.record(1)
-        return connection.send(binary, doNotConnect)
+        return connection.send(binary, opts.connect)
     }
 
     private isConnectionToSelf(peerDescriptor: PeerDescriptor): boolean {
@@ -294,8 +292,8 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     public getConnection(peerDescriptor: PeerDescriptor): ManagedConnection | undefined {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.connections.get(peerIdKey)
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        return this.connections.get(nodeId)
     }
 
     public getLocalPeerDescriptor(): PeerDescriptor {
@@ -303,18 +301,18 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     public hasConnection(peerDescriptor: PeerDescriptor): boolean {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.connections.has(peerIdKey)
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        return this.connections.has(nodeId)
     }
 
     public hasLocalLockedConnection(peerDescriptor: PeerDescriptor): boolean {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.locks.isLocalLocked(peerIdKey)
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        return this.locks.isLocalLocked(nodeId)
     }
 
     public hasRemoteLockedConnection(peerDescriptor: PeerDescriptor): boolean {
-        const peerIdKey = keyFromPeerDescriptor(peerDescriptor)
-        return this.locks.isRemoteLocked(peerIdKey)
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        return this.locks.isRemoteLocked(nodeId)
     }
 
     public handleMessage(message: Message): void {
@@ -370,11 +368,11 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     private onDisconnected(connection: ManagedConnection, gracefulLeave: boolean) {
         logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()) + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
 
-        const peerIdKey = keyFromPeerDescriptor(connection.getPeerDescriptor()!)
-        const storedConnection = this.connections.get(peerIdKey)
+        const nodeId = getNodeIdFromPeerDescriptor(connection.getPeerDescriptor()!)
+        const storedConnection = this.connections.get(nodeId)
         if (storedConnection && storedConnection.connectionId.equals(connection.connectionId)) {
-            this.locks.clearAllLocks(peerIdKey)
-            this.connections.delete(peerIdKey)
+            this.locks.clearAllLocks(nodeId)
+            this.connections.delete(nodeId)
             logger.trace(getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor())
                 + ' deleted connection in onDisconnected() gracefulLeave: ' + gracefulLeave)
             this.emit('disconnected', connection.getPeerDescriptor()!, gracefulLeave)
@@ -395,7 +393,6 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return false
         }
         logger.trace('onNewConnection()')
-        connection.offeredAsIncoming = true
         if (!this.acceptNewConnection(connection)) {
             return false
         }
@@ -416,13 +413,13 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     private acceptNewConnection(newConnection: ManagedConnection): boolean {
         logger.trace(getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' acceptIncomingConnection()')
         const newPeerID = peerIdFromPeerDescriptor(newConnection.getPeerDescriptor()!)
-        const peerIdKey = keyFromPeerDescriptor(newConnection.getPeerDescriptor()!)
-        if (this.connections.has(peerIdKey)) {
+        const nodeId = getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!)
+        if (this.connections.has(nodeId)) {
             if (newPeerID.hasSmallerHashThan(peerIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
                 logger.trace(getNodeIdOrUnknownFromPeerDescriptor(newConnection.getPeerDescriptor())
                     + ' acceptIncomingConnection() replace current connection')
                 // replace the current connection
-                const oldConnection = this.connections.get(newPeerID.toKey())!
+                const oldConnection = this.connections.get(nodeId)!
                 logger.trace('replaced: ' + getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!))
                 const buffer = oldConnection.stealOutputBuffer()
 
@@ -438,14 +435,14 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         }
 
         logger.trace(getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor()!) + ' added to connections at acceptIncomingConnection')
-        this.connections.set(peerIdKey, newConnection)
+        this.connections.set(nodeId, newConnection)
 
         return true
     }
 
     private async closeConnection(peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string): Promise<void> {
         logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'closeConnection() ' + reason)
-        const id = keyFromPeerDescriptor(peerDescriptor)
+        const id = getNodeIdFromPeerDescriptor(peerDescriptor)
         this.locks.clearAllLocks(id)
         if (this.connections.has(id)) {
             const connectionToClose = this.connections.get(id)!
@@ -461,13 +458,15 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
-            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
+            'DUMMY',
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
         )
-        this.locks.addLocalLocked(peerIdKey, lockId)
+        this.locks.addLocalLocked(nodeId, lockId)
         rpcRemote.lockRequest(lockId)
             .then((_accepted) => logger.trace('LockRequest successful'))
             .catch((err) => { logger.debug(err) })
@@ -477,14 +476,16 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.removeLocalLocked(peerIdKey, lockId)
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        this.locks.removeLocalLocked(nodeId, lockId)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
-            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
+            'DUMMY',
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
         )
-        if (this.connections.has(peerIdKey)) {
+        if (this.connections.has(nodeId)) {
             rpcRemote.unlockRequest(lockId)
         }
     }
@@ -493,22 +494,21 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.addWeakLocked(peerIdKey)
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        this.locks.addWeakLocked(nodeId)
     }
 
     public weakUnlockConnection(targetDescriptor: PeerDescriptor): void {
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const peerIdKey = keyFromPeerDescriptor(targetDescriptor)
-        this.locks.removeWeakLocked(peerIdKey)
-
+        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        this.locks.removeWeakLocked(nodeId)
     }
 
     private async gracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
 
-        const connection = this.connections.get(peerIdFromPeerDescriptor(targetDescriptor).toKey())
+        const connection = this.connections.get(getNodeIdFromPeerDescriptor(targetDescriptor))
 
         if (!connection) {
             logger.debug('gracefullyDisconnectedAsync() tried on a non-existing connection')
@@ -516,6 +516,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         }
 
         const promise = new Promise<void>((resolve, _reject) => {
+            // TODO use config option or named constant?
             // eslint-disable-next-line promise/catch-or-return
             waitForEvent3<ManagedConnectionEvents>(connection, 'disconnected', 2000).then(() => {
                 logger.trace('disconnected event received in gracefullyDisconnectAsync()')
@@ -546,7 +547,9 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
-            toProtoRpcClient(new ConnectionLockRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
+            'DUMMY',
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
         )
         try {
             await rpcRemote.gracefulDisconnect(disconnectMode)