@streamr/dht 101.1.1 → 102.0.0-beta.0

package/{src/proto → generated}/packages/dht/protos/DhtRpc.client.ts

@@ -7,6 +7,7 @@ import type { ExternalStoreDataRequest } from "./DhtRpc";
 import type { ExternalFetchDataResponse } from "./DhtRpc";
 import type { ExternalFetchDataRequest } from "./DhtRpc";
 import { ConnectionLockRpc } from "./DhtRpc";
+import type { SetPrivateRequest } from "./DhtRpc";
 import type { DisconnectNotice } from "./DhtRpc";
 import type { UnlockRequest } from "./DhtRpc";
 import type { LockResponse } from "./DhtRpc";
@@ -336,6 +337,10 @@ export interface IConnectionLockRpcClient {
      * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
     gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, Empty>;
+    /**
+     * @generated from protobuf rpc: setPrivate(dht.SetPrivateRequest) returns (google.protobuf.Empty);
+     */
+    setPrivate(input: SetPrivateRequest, options?: RpcOptions): UnaryCall<SetPrivateRequest, Empty>;
 }
 /**
  * @generated from protobuf service dht.ConnectionLockRpc
@@ -367,6 +372,13 @@ export class ConnectionLockRpcClient implements IConnectionLockRpcClient, Servic
         const method = this.methods[2], opt = this._transport.mergeOptions(options);
         return stackIntercept<DisconnectNotice, Empty>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: setPrivate(dht.SetPrivateRequest) returns (google.protobuf.Empty);
+     */
+    setPrivate(input: SetPrivateRequest, options?: RpcOptions): UnaryCall<SetPrivateRequest, Empty> {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept<SetPrivateRequest, Empty>("unary", this._transport, method, opt, input);
+    }
 }
 /**
  * @generated from protobuf service dht.ExternalApiRpc

package/{src/proto → generated}/packages/dht/protos/DhtRpc.server.ts

@@ -5,6 +5,7 @@ import { ExternalStoreDataResponse } from "./DhtRpc";
 import { ExternalStoreDataRequest } from "./DhtRpc";
 import { ExternalFetchDataResponse } from "./DhtRpc";
 import { ExternalFetchDataRequest } from "./DhtRpc";
+import { SetPrivateRequest } from "./DhtRpc";
 import { DisconnectNotice } from "./DhtRpc";
 import { UnlockRequest } from "./DhtRpc";
 import { LockResponse } from "./DhtRpc";
@@ -144,6 +145,10 @@ export interface IConnectionLockRpc<T = ServerCallContext> {
      * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
     gracefulDisconnect(request: DisconnectNotice, context: T): Promise<Empty>;
+    /**
+     * @generated from protobuf rpc: setPrivate(dht.SetPrivateRequest) returns (google.protobuf.Empty);
+     */
+    setPrivate(request: SetPrivateRequest, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service dht.ExternalApiRpc

package/{src/proto → generated}/packages/dht/protos/DhtRpc.ts

@@ -582,6 +582,15 @@ export interface DisconnectNotice {
      */
     disconnectMode: DisconnectMode;
 }
+/**
+ * @generated from protobuf message dht.SetPrivateRequest
+ */
+export interface SetPrivateRequest {
+    /**
+     * @generated from protobuf field: bool isPrivate = 1;
+     */
+    isPrivate: boolean;
+}
 /**
  * @generated from protobuf message dht.ExternalFetchDataRequest
  */
@@ -1154,6 +1163,18 @@ class DisconnectNotice$Type extends MessageType<DisconnectNotice> {
  */
 export const DisconnectNotice = new DisconnectNotice$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class SetPrivateRequest$Type extends MessageType<SetPrivateRequest> {
+    constructor() {
+        super("dht.SetPrivateRequest", [
+            { no: 1, name: "isPrivate", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.SetPrivateRequest
+ */
+export const SetPrivateRequest = new SetPrivateRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class ExternalFetchDataRequest$Type extends MessageType<ExternalFetchDataRequest> {
     constructor() {
         super("dht.ExternalFetchDataRequest", [
@@ -1233,7 +1254,8 @@ export const WebrtcConnectorRpc = new ServiceType("dht.WebrtcConnectorRpc", [
 export const ConnectionLockRpc = new ServiceType("dht.ConnectionLockRpc", [
     { name: "lockRequest", options: {}, I: LockRequest, O: LockResponse },
     { name: "unlockRequest", options: {}, I: UnlockRequest, O: Empty },
-    { name: "gracefulDisconnect", options: {}, I: DisconnectNotice, O: Empty }
+    { name: "gracefulDisconnect", options: {}, I: DisconnectNotice, O: Empty },
+    { name: "setPrivate", options: {}, I: SetPrivateRequest, O: Empty }
 ]);
 /**
  * @generated ServiceType for protobuf service dht.ExternalApiRpc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/dht",
-  "version": "101.1.1",
+  "version": "102.0.0-beta.0",
   "description": "Streamr Network DHT",
   "repository": {
     "type": "git",
@@ -15,7 +15,7 @@
     "generate-protoc-code": "./proto.sh",
     "build": "tsc -b tsconfig.node.json",
     "build-browser": "webpack --mode=development --progress",
-    "check": "tsc -p ./tsconfig.jest.json --noEmit",
+    "check": "tsc -p ./tsconfig.jest.json",
     "clean": "jest --clearCache || true; rm -rf dist *.tsbuildinfo node_modules/.cache || true",
     "eslint": "eslint --cache --cache-location=node_modules/.cache/.eslintcache/ '*/**/*.{js,ts}'",
     "test": "npm run test-unit && npm run test-integration && npm run test-end-to-end",
@@ -29,17 +29,17 @@
     "@js-sdsl/ordered-map": "^4.4.2",
     "@protobuf-ts/runtime": "^2.8.2",
     "@protobuf-ts/runtime-rpc": "^2.8.2",
-    "@streamr/autocertifier-client": "101.1.1",
-    "@streamr/cdn-location": "101.1.1",
-    "@streamr/geoip-location": "101.1.1",
-    "@streamr/proto-rpc": "101.1.1",
-    "@streamr/utils": "101.1.1",
+    "@streamr/autocertifier-client": "102.0.0-beta.0",
+    "@streamr/cdn-location": "102.0.0-beta.0",
+    "@streamr/geoip-location": "102.0.0-beta.0",
+    "@streamr/proto-rpc": "102.0.0-beta.0",
+    "@streamr/utils": "102.0.0-beta.0",
     "eventemitter3": "^5.0.0",
     "heap": "^0.2.6",
     "ipaddr.js": "^2.0.1",
     "k-bucket": "^5.1.0",
     "lodash": "^4.17.21",
-    "lru-cache": "11.0.0",
+    "lru-cache": "11.0.1",
     "node-datachannel": "^0.10.1",
     "querystring": "0.2.1",
     "uuid": "^10.0.0",
@@ -48,15 +48,15 @@
   },
   "devDependencies": {
     "@streamr/browser-test-runner": "^0.0.1",
-    "@streamr/test-utils": "101.1.1",
+    "@streamr/test-utils": "102.0.0-beta.0",
     "@types/heap": "^0.2.34",
     "@types/k-bucket": "^5.0.1",
-    "@types/lodash": "^4.17.7",
+    "@types/lodash": "^4.17.10",
     "@types/uuid": "^10.0.0",
     "@types/websocket": "^1.0.10",
     "@types/ws": "^8.5.12",
     "jest-leak-detector": "^27.3.1",
-    "jest-matcher-utils": "^29.5.0",
+    "jest-matcher-utils": "^29.7.0",
     "ts-essentials": "^10.0.2"
   },
   "optionalDependencies": {

package/proto.sh

@@ -1,3 +1,2 @@
-mkdir -p ./src/proto
-# npx protoc --ts_out ./src/proto --ts_opt server_generic,generate_dependencies --proto_path ../.. packages/trackerless-network/protos/NetworkRpc.proto
-npx protoc --ts_out ./src/proto --ts_opt server_generic,generate_dependencies,long_type_number --proto_path ../.. packages/dht/protos/DhtRpc.proto
+mkdir -p ./generated
+npx protoc --ts_out ./generated --ts_opt server_generic,generate_dependencies,long_type_number --proto_path ../.. packages/dht/protos/DhtRpc.proto

package/protos/DhtRpc.proto

@@ -50,6 +50,7 @@ service ConnectionLockRpc {
   rpc lockRequest (LockRequest) returns (LockResponse);
   rpc unlockRequest (UnlockRequest) returns (google.protobuf.Empty);
   rpc gracefulDisconnect (DisconnectNotice) returns (google.protobuf.Empty);
+  rpc setPrivate (SetPrivateRequest) returns (google.protobuf.Empty);
 }
 
 service ExternalApiRpc {
@@ -301,6 +302,10 @@ message DisconnectNotice {
   DisconnectMode disconnectMode = 1;
 }
 
+message SetPrivateRequest {
+  bool isPrivate = 1;
+}
+
 message ExternalFetchDataRequest {
   bytes key = 1;
 }

package/src/connection/Connection.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'eventemitter3'
-import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { ConnectionID, ConnectionType, ConnectionEvents } from './IConnection'
 import { v4 as uuid } from 'uuid'
 

package/src/connection/ConnectionLockRpcLocal.ts

@@ -1,25 +1,27 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
-import { Empty } from '../proto/google/protobuf/empty'
+import { Empty } from '../../generated/google/protobuf/empty'
 import {
     DisconnectMode,
     DisconnectNotice,
     LockRequest,
     LockResponse,
     PeerDescriptor,
-    UnlockRequest
-} from '../proto/packages/dht/protos/DhtRpc'
-import { IConnectionLockRpc } from '../proto/packages/dht/protos/DhtRpc.server'
+    UnlockRequest,
+    SetPrivateRequest
+} from '../../generated/packages/dht/protos/DhtRpc'
+import { IConnectionLockRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { getNodeIdOrUnknownFromPeerDescriptor } from './ConnectionManager'
 import { LockID } from './ConnectionLockStates'
-import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, toNodeId } from '../identifiers'
 
 interface ConnectionLockRpcLocalOptions {
     addRemoteLocked: (id: DhtAddress, lockId: LockID) => void
     removeRemoteLocked: (id: DhtAddress, lockId: LockID) => void
     closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => Promise<void>
     getLocalPeerDescriptor: () => PeerDescriptor
+    setPrivate: (id: DhtAddress, isPrivate: boolean) => void
 }
 
 const logger = new Logger(module)
@@ -40,7 +42,7 @@ export class ConnectionLockRpcLocal implements IConnectionLockRpc {
             }
             return response
         }
-        const remoteNodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const remoteNodeId = toNodeId(senderPeerDescriptor)
         this.options.addRemoteLocked(remoteNodeId, lockRequest.lockId)
         const response: LockResponse = {
             accepted: true
@@ -50,7 +52,7 @@ export class ConnectionLockRpcLocal implements IConnectionLockRpc {
 
     async unlockRequest(unlockRequest: UnlockRequest, context: ServerCallContext): Promise<Empty> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const nodeId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        const nodeId = toNodeId(senderPeerDescriptor)
         this.options.removeRemoteLocked(nodeId, unlockRequest.lockId)
         return {}
     }
@@ -66,4 +68,11 @@ export class ConnectionLockRpcLocal implements IConnectionLockRpc {
         }
         return {}
     }
+
+    async setPrivate(request: SetPrivateRequest, context: ServerCallContext): Promise<Empty> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const senderId = toNodeId(senderPeerDescriptor)            
+        this.options.setPrivate(senderId, request.isPrivate)
+        return {}
+    }
 }

package/src/connection/ConnectionLockRpcRemote.ts

@@ -1,16 +1,16 @@
 import { Logger } from '@streamr/utils'
 import { RpcRemote } from '../dht/contact/RpcRemote'
-import { DisconnectMode, DisconnectNotice, LockRequest, UnlockRequest } from '../proto/packages/dht/protos/DhtRpc'
-import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { DisconnectMode, DisconnectNotice, LockRequest, UnlockRequest, SetPrivateRequest } from '../../generated/packages/dht/protos/DhtRpc'
+import { ConnectionLockRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { LockID } from './ConnectionLockStates'
-import { getNodeIdFromPeerDescriptor } from '../identifiers'
+import { toNodeId } from '../identifiers'
 
 const logger = new Logger(module)
 
 export class ConnectionLockRpcRemote extends RpcRemote<ConnectionLockRpcClient> {
 
     public async lockRequest(lockId: LockID): Promise<boolean> {
-        logger.trace(`Requesting locked connection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting locked connection to ${toNodeId(this.getPeerDescriptor())}`)
         const request: LockRequest = {
             lockId
         }
@@ -25,7 +25,7 @@ export class ConnectionLockRpcRemote extends RpcRemote<ConnectionLockRpcClient>
     }
 
     public unlockRequest(lockId: LockID): void {
-        logger.trace(`Requesting connection to be unlocked from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting connection to be unlocked from ${toNodeId(this.getPeerDescriptor())}`)
         const request: UnlockRequest = {
             lockId
         }
@@ -38,7 +38,7 @@ export class ConnectionLockRpcRemote extends RpcRemote<ConnectionLockRpcClient>
     }
 
     public async gracefulDisconnect(disconnectMode: DisconnectMode): Promise<void> {
-        logger.trace(`Notifying a graceful disconnect to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Notifying a graceful disconnect to ${toNodeId(this.getPeerDescriptor())}`)
         const request: DisconnectNotice = {
             disconnectMode
         }
@@ -49,4 +49,16 @@ export class ConnectionLockRpcRemote extends RpcRemote<ConnectionLockRpcClient>
         })
         await this.getClient().gracefulDisconnect(request, options)
     }
+
+    public async setPrivate(isPrivate: boolean): Promise<void> {
+        logger.trace(`Setting isPrivate: ${isPrivate} for ${toNodeId(this.getPeerDescriptor())}`)
+        const request: SetPrivateRequest = {
+            isPrivate
+        }
+        const options = this.formDhtRpcOptions({
+            connect: false,
+            notification: true
+        })
+        await this.getClient().setPrivate(request, options)
+    }
 }

package/src/connection/ConnectionLockStates.ts

@@ -12,6 +12,8 @@ export class ConnectionLockStates {
     // TODO: remove weakLocks use localLocks instead. When opening weakLocks from the ConnectioManager,
     // simply do not send lock requests.
     private weakLocks: Map<DhtAddress, Set<LockID>> = new Map()
+    // Used to filter proxy connections from the connections view
+    private remotePrivateConnections: Set<DhtAddress> = new Set()
 
     public getLocalLockedConnectionCount(): number {
         return this.localLocks.size
@@ -99,6 +101,22 @@ export class ConnectionLockStates {
         }
     }
 
+    public addPrivate(id: DhtAddress): void {
+        this.remotePrivateConnections.add(id)
+    }
+
+    public removePrivate(id: DhtAddress): void {
+        this.remotePrivateConnections.delete(id)
+    }
+
+    public getPrivateConnections(): Set<DhtAddress> {
+        return this.remotePrivateConnections
+    }
+
+    public isPrivate(id: DhtAddress): boolean {
+        return this.remotePrivateConnections.has(id)
+    }
+
     public clearAllLocks(id: DhtAddress): void {
         this.localLocks.delete(id)
         this.remoteLocks.delete(id)

package/src/connection/ConnectionManager.ts

@@ -10,9 +10,10 @@ import {
     LockResponse,
     Message,
     PeerDescriptor,
-    UnlockRequest
-} from '../proto/packages/dht/protos/DhtRpc'
-import { ConnectionLockRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
+    UnlockRequest,
+    SetPrivateRequest
+} from '../../generated/packages/dht/protos/DhtRpc'
+import { ConnectionLockRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { DEFAULT_SEND_OPTIONS, ITransport, SendOptions, TransportEvents } from '../transport/ITransport'
 import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
 import { ConnectionLockStates, LockID } from './ConnectionLockStates'
@@ -21,7 +22,7 @@ import { ManagedConnection, Events as ManagedConnectionEvents } from './ManagedC
 import { ConnectionLockRpcRemote } from './ConnectionLockRpcRemote'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ConnectionLockRpcLocal } from './ConnectionLockRpcLocal'
-import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, toNodeId } from '../identifiers'
 import { getOfferer } from '../helpers/offering'
 import { ConnectionsView } from './ConnectionsView'
 import { OutputBuffer } from './OutputBuffer'
@@ -31,6 +32,7 @@ import { PendingConnection } from './PendingConnection'
 export interface ConnectionManagerOptions {
     maxConnections?: number
     metricsContext: MetricsContext
+    allowIncomingPrivateConnections: boolean
     createConnectorFacade: () => ConnectorFacade
 }
 
@@ -108,7 +110,7 @@ const INTERNAL_SERVICE_ID = 'system/connection-manager'
 // - if ManagedConnection#peerDescriptor is never undefined
 export const getNodeIdOrUnknownFromPeerDescriptor = (peerDescriptor: PeerDescriptor | undefined): string => {
     if (peerDescriptor !== undefined) {
-        return getNodeIdFromPeerDescriptor(peerDescriptor)
+        return toNodeId(peerDescriptor)
     } else {
         return 'unknown'
     }
@@ -127,6 +129,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     private rpcCommunicator?: RoutingRpcCommunicator
     private disconnectorIntervalRef?: NodeJS.Timeout
     private state = ConnectionManagerState.IDLE
+    private privateClientMode = false
 
     constructor(options: ConnectionManagerOptions) {
         super()
@@ -154,7 +157,18 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             removeRemoteLocked: (id: DhtAddress, lockId: LockID) => this.locks.removeRemoteLocked(id, lockId),
             closeConnection: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string) => 
                 this.closeConnection(peerDescriptor, gracefulLeave, reason),
-            getLocalPeerDescriptor: () => this.getLocalPeerDescriptor()
+            getLocalPeerDescriptor: () => this.getLocalPeerDescriptor(),
+            setPrivate: (id: DhtAddress, isPrivate: boolean) => {
+                if (!this.options.allowIncomingPrivateConnections) {
+                    logger.debug(`node ${id} attemted to set a connection as private, but it is not allowed`)
+                    return
+                }
+                if (isPrivate) {
+                    this.locks.addPrivate(id)
+                } else {
+                    this.locks.removePrivate(id)
+                }
+            }
         })
         this.rpcCommunicator.registerRpcMethod(LockRequest, LockResponse, 'lockRequest',
             (req: LockRequest, context: ServerCallContext) => lockRpcLocal.lockRequest(req, context))
@@ -162,6 +176,8 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             (req: UnlockRequest, context: ServerCallContext) => lockRpcLocal.unlockRequest(req, context))
         this.rpcCommunicator.registerRpcNotification(DisconnectNotice, 'gracefulDisconnect',
             (req: DisconnectNotice, context: ServerCallContext) => lockRpcLocal.gracefulDisconnect(req, context))
+        this.rpcCommunicator.registerRpcNotification(SetPrivateRequest, 'setPrivate',
+            (req: SetPrivateRequest, context: ServerCallContext) => lockRpcLocal.setPrivate(req, context))
     }
 
     /*
@@ -173,14 +189,15 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return
         }
         const disconnectionCandidates = new SortedContactList<ManagedConnection>({
-            referenceId: getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), 
+            referenceId: toNodeId(this.getLocalPeerDescriptor()), 
             maxSize: 100000,  // TODO use options option or named constant?
             allowToContainReferenceId: false
         })
         this.endpoints.forEach((endpoint) => {
             if (endpoint.connected) {
                 const connection = endpoint.connection
-                if (!this.locks.isLocked(connection.getNodeId()) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
+                const nodeId = connection.getNodeId()
+                if (!this.locks.isLocked(nodeId) && !this.locks.isPrivate(nodeId) && Date.now() - connection.getLastUsedTimestamp() > maxIdleTime) {
                     logger.trace('disconnecting in timeout interval: ' + getNodeIdOrUnknownFromPeerDescriptor(connection.getPeerDescriptor()))
                     disconnectionCandidates.addContact(connection)
                 }
@@ -189,7 +206,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         const disconnectables = disconnectionCandidates.getFurthestContacts(this.endpoints.size - maxConnections)
         for (const disconnectable of disconnectables) {
             const peerDescriptor = disconnectable.getPeerDescriptor()!
-            logger.trace('garbageCollecting ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+            logger.trace('garbageCollecting ' + toNodeId(peerDescriptor))
             this.gracefullyDisconnectAsync(peerDescriptor, DisconnectMode.NORMAL).catch((_e) => { })
         }
     }
@@ -273,7 +290,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.isConnectionToSelf(peerDescriptor)) {
             throw new Err.CannotConnectToSelf('Cannot send to self')
         }
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         logger.trace(`Sending message to: ${nodeId}`)
         message = {
             ...message,
@@ -283,7 +300,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (!connection && opts.connect) {
             connection = this.connectorFacade.createConnection(peerDescriptor)
             this.onNewConnection(connection)
-        } else if (!connection) {
+        } else if (!connection || (connection && !this.endpoints.get(nodeId)!.connected && !opts.connect)) {
             throw new Err.SendFailed('No connection to target, connect flag is false')
         }
         const binary = Message.toBinary(message)
@@ -317,7 +334,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
 
     public hasConnection(nodeId: DhtAddress): boolean {
         // TODO if we remove filtering in getConnections, this can just be this.connection.has(nodeId)
-        return this.getConnections().some((c) => getNodeIdFromPeerDescriptor(c) == nodeId)
+        return this.getConnections().some((c) => toNodeId(c) == nodeId)
     }
 
     public getConnectionCount(): number {
@@ -341,7 +358,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             return
         }
         if (this.duplicateMessageDetector.isMostLikelyDuplicate(message.messageId)) {
-            logger.trace('handleMessage filtered duplicate ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
+            logger.trace('handleMessage filtered duplicate ' + toNodeId(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             return
         }
@@ -349,7 +366,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (message.serviceId === INTERNAL_SERVICE_ID) {
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
+            logger.trace('emit "message" ' + toNodeId(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
@@ -365,6 +382,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         try {
             message = Message.fromBinary(data)
         } catch (e) {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             logger.debug(`Parsing incoming data into Message failed: ${e}`)
             return
         }
@@ -372,6 +390,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         try {
             this.handleMessage(message)
         } catch (e) {
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
             logger.debug(`Handling incoming data failed: ${e}`)
         }
     }
@@ -381,7 +400,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         managedConnection.on('managedData', this.onData)
         managedConnection.once('disconnected', (gracefulLeave: boolean) => this.onDisconnected(peerDescriptor, gracefulLeave))
 
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         const endpoint = this.endpoints.get(nodeId)! as ConnectingEndpoint
         const outputBuffer = endpoint.buffer
         const pendingConnection = endpoint.connection
@@ -396,12 +415,15 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             connected: true,
             connection: managedConnection
         })
+        if (this.privateClientMode) {
+            this.setPrivateForConnection(peerDescriptor, this.privateClientMode).catch(() => {})
+        }
         this.emit('connected', peerDescriptor)
         this.onConnectionCountChange()
     }
 
     private onDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean) {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         logger.trace(nodeId + ' onDisconnected() gracefulLeave: ' + gracefulLeave)
         const endpoint = this.endpoints.get(nodeId)
         if (endpoint) {
@@ -430,10 +452,10 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private acceptNewConnection(newConnection: PendingConnection): boolean {
-        const nodeId = getNodeIdFromPeerDescriptor(newConnection.getPeerDescriptor())
+        const nodeId = toNodeId(newConnection.getPeerDescriptor())
         logger.trace(nodeId + ' acceptNewConnection()')
         if (this.endpoints.has(nodeId)) {
-            if (getOfferer(getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()), nodeId) === 'remote') {
+            if (getOfferer(toNodeId(this.getLocalPeerDescriptor()), nodeId) === 'remote') {
                 let buffer: OutputBuffer | undefined
                 const endpoint = this.endpoints.get(nodeId)!
                 // This is a rare occurance but it does happen from time to time.
@@ -467,7 +489,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private async closeConnection(peerDescriptor: PeerDescriptor, gracefulLeave: boolean, reason?: string): Promise<void> {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         logger.trace(nodeId + ' ' + 'closeConnection() ' + reason)
         this.locks.clearAllLocks(nodeId)
         if (this.endpoints.has(nodeId)) {
@@ -483,7 +505,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        const nodeId = toNodeId(targetDescriptor)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
             targetDescriptor,
@@ -500,7 +522,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
         if (this.state === ConnectionManagerState.STOPPED || areEqualPeerDescriptors(targetDescriptor, this.getLocalPeerDescriptor())) {
             return
         }
-        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        const nodeId = toNodeId(targetDescriptor)
         this.locks.removeLocalLocked(nodeId, lockId)
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
@@ -514,21 +536,55 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     public weakLockConnection(nodeId: DhtAddress, lockId: LockID): void {
-        if (this.state === ConnectionManagerState.STOPPED || (nodeId === getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
+        if (this.state === ConnectionManagerState.STOPPED || (nodeId === toNodeId(this.getLocalPeerDescriptor()))) {
             return
         }
         this.locks.addWeakLocked(nodeId, lockId)
     }
 
     public weakUnlockConnection(nodeId: DhtAddress, lockId: LockID): void {
-        if (this.state === ConnectionManagerState.STOPPED || (nodeId === getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor()))) {
+        if (this.state === ConnectionManagerState.STOPPED || (nodeId === toNodeId(this.getLocalPeerDescriptor()))) {
             return
         }
         this.locks.removeWeakLocked(nodeId, lockId)
     }
 
+    public async enablePrivateClientMode(): Promise<void> {
+        this.privateClientMode = true
+        await Promise.all(Array.from(this.endpoints.values()).map((endpoint) => {
+            if (endpoint.connected) {
+                const peerDescription = endpoint.connection.getPeerDescriptor()
+                return this.setPrivateForConnection(peerDescription!, true)
+            }
+        }))
+    }
+
+    public async disablePrivateClientMode(): Promise<void> {
+        this.privateClientMode = false
+        await Promise.all(Array.from(this.endpoints.values()).map((endpoint) => {
+            if (endpoint.connected) {
+                const peerDescription = endpoint.connection.getPeerDescriptor()
+                return this.setPrivateForConnection(peerDescription!, false)
+            }
+        }))
+    }
+
+    public isPrivateClientMode(): boolean {
+        return this.privateClientMode
+    }
+
+    private async setPrivateForConnection(targetDescriptor: PeerDescriptor, isPrivate: boolean): Promise<void> {
+        const rpcRemote = new ConnectionLockRpcRemote(
+            this.getLocalPeerDescriptor(),
+            targetDescriptor,
+            this.rpcCommunicator!,
+            ConnectionLockRpcClient
+        )
+        await rpcRemote.setPrivate(isPrivate)
+    }
+
     private async gracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
-        const endpoint = this.endpoints.get(getNodeIdFromPeerDescriptor(targetDescriptor))
+        const endpoint = this.endpoints.get(toNodeId(targetDescriptor))
 
         if (!endpoint) {
             logger.debug('gracefullyDisconnectedAsync() tried on a non-existing connection')
@@ -565,7 +621,7 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
     }
 
     private async doGracefullyDisconnectAsync(targetDescriptor: PeerDescriptor, disconnectMode: DisconnectMode): Promise<void> {
-        const nodeId = getNodeIdFromPeerDescriptor(targetDescriptor)
+        const nodeId = toNodeId(targetDescriptor)
         logger.trace(nodeId + ' gracefullyDisconnectAsync()')
         const rpcRemote = new ConnectionLockRpcRemote(
             this.getLocalPeerDescriptor(),
@@ -585,11 +641,21 @@ export class ConnectionManager extends EventEmitter<TransportEvents> implements
             .map((endpoint) => endpoint)
             // TODO is this filtering needed? (if it is, should we do the same filtering e.g.
             // in getConnection() or in other methods which access this.endpoints directly?)
-            .filter((endpoint) => endpoint.connected)
+            .filter((endpoint) => endpoint.connected && !this.locks.isPrivate(toNodeId(endpoint.connection.getPeerDescriptor()!)))
             .map((endpoint) => endpoint.connection.getPeerDescriptor()!)
     }
 
     private onConnectionCountChange() {
         this.metrics.connectionAverageCount.record(this.endpoints.size)
     }
+
+    public getDiagnosticInfo(): Record<string, unknown> {
+        const managedConnections: ManagedConnection[] = Array.from(this.endpoints.values())
+            .filter((endpoint) => endpoint.connected)
+            .map((endpoint) => endpoint.connection as ManagedConnection)
+        return {
+            connections: managedConnections.map((connection) => connection.getDiagnosticInfo()),
+            connectionCount: this.endpoints.size
+        }
+    }
 }