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

package/src/connection/webrtc/WebrtcConnector.ts

@@ -17,6 +17,7 @@ import { ManagedConnection } from '../ManagedConnection'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
@@ -67,23 +68,23 @@ export class WebrtcConnector {
 
     constructor(
         config: WebrtcConnectorConfig,
-        onIncomingConnection: (connection: ManagedConnection) => boolean
+        onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         this.config = config
         this.iceServers = config.iceServers ?? []
         this.rpcCommunicator = new ListeningRpcCommunicator(WebrtcConnector.WEBRTC_CONNECTOR_SERVICE_ID, config.transport, {
             rpcRequestTimeout: 15000
         })
-        this.registerLocalRpcMethods(config, onIncomingConnection)
+        this.registerLocalRpcMethods(config, onNewConnection)
     }
 
     private registerLocalRpcMethods(
         config: WebrtcConnectorConfig,
-        onIncomingConnection: (connection: ManagedConnection) => boolean
+        onNewConnection: (connection: ManagedConnection) => boolean
     ) {
         const localRpc = new WebrtcConnectorRpcLocal({
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            onIncomingConnection,
+            onNewConnection,
             ongoingConnectAttempts: this.ongoingConnectAttempts,
             rpcCommunicator: this.rpcCommunicator,
             getLocalPeerDescriptor: () => this.localPeerDescriptor!,
@@ -132,7 +133,7 @@ export class WebrtcConnector {
             throw new Err.CannotConnectToSelf('Cannot open WebRTC Connection to self')
         }
 
-        logger.trace(`Opening WebRTC connection to ${keyFromPeerDescriptor(targetPeerDescriptor)}`)
+        logger.trace(`Opening WebRTC connection to ${getNodeIdFromPeerDescriptor(targetPeerDescriptor)}`)
 
         const peerKey = keyFromPeerDescriptor(targetPeerDescriptor)
         const existingConnection = this.ongoingConnectAttempts.get(peerKey)
@@ -158,7 +159,7 @@ export class WebrtcConnector {
             managedConnection = new ManagedWebrtcConnection(this.localPeerDescriptor!, undefined, connection)
         }
 
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
         this.ongoingConnectAttempts.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
 

package/src/connection/webrtc/WebrtcConnectorRpcLocal.ts

@@ -24,7 +24,7 @@ const logger = new Logger(module)
 
 interface WebrtcConnectorRpcLocalConfig {
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection 
-    onIncomingConnection: (connection: ManagedConnection) => boolean
+    onNewConnection: (connection: ManagedConnection) => boolean
     // TODO pass accessor methods instead of passing a mutable entity
     ongoingConnectAttempts: Map<PeerIDKey, ManagedWebrtcConnection>
     rpcCommunicator: ListeningRpcCommunicator
@@ -46,8 +46,8 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
             return {}
         }
         const managedConnection = this.config.connect(targetPeerDescriptor)
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
-        this.config.onIncomingConnection(managedConnection)
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
+        this.config.onNewConnection(managedConnection)
         return {}
     }
 
@@ -60,9 +60,9 @@ export class WebrtcConnectorRpcLocal implements IWebrtcConnectorRpc {
         if (!managedConnection) {
             connection = new NodeWebrtcConnection({ remotePeerDescriptor: remotePeer })
             managedConnection = new ManagedWebrtcConnection(this.config.getLocalPeerDescriptor(), undefined, connection)
-            managedConnection.setPeerDescriptor(remotePeer)
+            managedConnection.setRemotePeerDescriptor(remotePeer)
             this.config.ongoingConnectAttempts.set(peerKey, managedConnection)
-            this.config.onIncomingConnection(managedConnection)
+            this.config.onNewConnection(managedConnection)
             const remoteConnector = new WebrtcConnectorRpcRemote(
                 this.config.getLocalPeerDescriptor(),
                 remotePeer,

package/src/connection/websocket/ClientWebsocket.ts

@@ -87,6 +87,8 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
+        this.emit('disconnected', gracefulLeave, undefined, 'close() called')
+        this.removeAllListeners()
         if (!this.destroyed) {
             logger.trace(`Closing socket for connection ${this.connectionId.toString()}`)
             this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
@@ -105,6 +107,7 @@ export class ClientWebsocket extends EventEmitter<ConnectionEvents> implements I
     }
 
     public destroy(): void {
+        logger.trace('destroy() a connection')
         if (!this.destroyed) {
             this.removeAllListeners()
             if (this.socket) {

package/src/connection/websocket/ServerWebsocket.ts

@@ -80,6 +80,8 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
     }
 
     public async close(gracefulLeave: boolean): Promise<void> {
+        this.emit('disconnected', gracefulLeave, undefined, 'close() called')
+        this.removeAllListeners()
         if (!this.stopped) {
             this.socket?.close(gracefulLeave === true ? GOING_AWAY : undefined)
         } else {

package/src/connection/websocket/WebsocketConnector.ts

@@ -7,6 +7,7 @@ import { WebsocketConnectorRpcRemote } from './WebsocketConnectorRpcRemote'
 import {
     ConnectivityMethod,
     ConnectivityResponse,
+    HandshakeError,
     PeerDescriptor,
     WebsocketConnectionRequest,
     WebsocketConnectionResponse
@@ -21,7 +22,7 @@ import { PeerIDKey } from '../../helpers/PeerID'
 import { ServerWebsocket } from './ServerWebsocket'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Handshaker } from '../Handshaker'
-import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ParsedUrlQuery } from 'querystring'
 import { range, sample } from 'lodash'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
@@ -30,16 +31,18 @@ import { WebsocketServerStartError } from '../../helpers/errors'
 import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
 const logger = new Logger(module)
 
-export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod): string => {
-    return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port
+export type Action = 'connectivityRequest' | 'connectivityProbe'
+
+export const connectivityMethodToWebsocketUrl = (ws: ConnectivityMethod, action?: Action): string => {
+    return (ws.tls ? 'wss://' : 'ws://') + ws.host + ':' + ws.port + ((action !== undefined) ? '?action=' + action : '')
 }
 
 const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 
-interface WebsocketConnectorConfig {
+export interface WebsocketConnectorConfig {
     transport: ITransport
     canConnect: (peerDescriptor: PeerDescriptor) => boolean
-    onIncomingConnection: (connection: ManagedConnection) => boolean
+    onNewConnection: (connection: ManagedConnection) => boolean
     portRange?: PortRange
     maxMessageSize?: number
     host?: string
@@ -58,7 +61,7 @@ export class WebsocketConnector {
     private readonly websocketServer?: WebsocketServer
     private connectivityChecker?: ConnectivityChecker
     private readonly ongoingConnectRequests: Map<PeerIDKey, ManagedConnection> = new Map()
-    private onIncomingConnection: (connection: ManagedConnection) => boolean
+    private onNewConnection: (connection: ManagedConnection) => boolean
     private host?: string
     private readonly entrypoints?: PeerDescriptor[]
     private readonly tlsCertificate?: TlsCertificate
@@ -79,7 +82,7 @@ export class WebsocketConnector {
             maxMessageSize: config.maxMessageSize,
             enableTls: config.serverEnableTls
         }) : undefined
-        this.onIncomingConnection = config.onIncomingConnection
+        this.onNewConnection = config.onNewConnection
         this.host = config.host
         this.entrypoints = config.entrypoints
         this.tlsCertificate = config.tlsCertificate
@@ -97,7 +100,7 @@ export class WebsocketConnector {
         const rpcLocal = new WebsocketConnectorRpcLocal({
             canConnect: (peerDescriptor: PeerDescriptor) => config.canConnect(peerDescriptor),
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            onIncomingConnection: (connection: ManagedConnection) => config.onIncomingConnection(connection),
+            onNewConnection: (connection: ManagedConnection) => config.onNewConnection(connection),
             abortSignal: this.abortController.signal
         })
         this.rpcCommunicator.registerRpcMethod(
@@ -116,8 +119,8 @@ export class WebsocketConnector {
 
     private attachHandshaker(connection: IConnection) {
         const handshaker = new Handshaker(this.localPeerDescriptor!, connection)
-        handshaker.once('handshakeRequest', (peerDescriptor: PeerDescriptor) => {
-            this.onServerSocketHandshakeRequest(peerDescriptor, connection)
+        handshaker.once('handshakeRequest', (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor?: PeerDescriptor) => {
+            this.onServerSocketHandshakeRequest(localPeerDescriptor, connection, remotePeerDescriptor)
         })
     }
 
@@ -143,19 +146,14 @@ export class WebsocketConnector {
     public async start(): Promise<void> {
         if (!this.abortController.signal.aborted && this.websocketServer) {
             this.websocketServer.on('connected', (connection: IConnection) => {
-
                 const serverSocket = connection as unknown as ServerWebsocket
-                if (serverSocket.resourceURL &&
-                    serverSocket.resourceURL.query) {
-                    const query = serverSocket.resourceURL.query as unknown as ParsedUrlQuery
-                    if (query.connectivityRequest) {
-                        logger.trace('Received connectivity request connection from ' + serverSocket.getRemoteAddress())
-                        this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
-                    } else if (query.connectivityProbe) {
-                        logger.trace('Received connectivity probe connection from ' + serverSocket.getRemoteAddress())
-                    } else {
-                        this.attachHandshaker(connection)
-                    }
+                const query = serverSocket.resourceURL.query as unknown as (ParsedUrlQuery | null)
+                const action = query?.action as (Action | undefined)
+                logger.trace('WebSocket client connected', { action, remoteAddress: serverSocket.getRemoteAddress() })
+                if (action === 'connectivityRequest') {
+                    this.connectivityChecker!.listenToIncomingConnectivityRequests(serverSocket)
+                } else if (action === 'connectivityProbe') {
+                    // no-op
                 } else {
                     this.attachHandshaker(connection)
                 }
@@ -190,7 +188,7 @@ export class WebsocketConnector {
                         }
                         return preconfiguredConnectivityResponse
                     } else {
-                        // Do real connectivity checking     
+                        // Do real connectivity checking
                         return await this.connectivityChecker!.sendConnectivityRequest(entryPoint, selfSigned)
                     }
                 }
@@ -225,8 +223,14 @@ export class WebsocketConnector {
 
             const url = connectivityMethodToWebsocketUrl(targetPeerDescriptor.websocket!)
 
-            const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_CLIENT, socket, undefined)
-            managedConnection.setPeerDescriptor(targetPeerDescriptor)
+            const managedConnection = new ManagedConnection(
+                this.localPeerDescriptor!,
+                ConnectionType.WEBSOCKET_CLIENT,
+                socket,
+                undefined,
+                targetPeerDescriptor
+            )
+            managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
 
             this.connectingConnections.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
 
@@ -255,32 +259,52 @@ export class WebsocketConnector {
             )
             remoteConnector.requestConnection(localPeerDescriptor.websocket!.host, localPeerDescriptor.websocket!.port)
         })
-        const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER)
+        const managedConnection = new ManagedConnection(
+            this.localPeerDescriptor!,
+            ConnectionType.WEBSOCKET_SERVER,
+            undefined,
+            undefined,
+            targetPeerDescriptor
+        )        
         managedConnection.on('disconnected', () => this.ongoingConnectRequests.delete(keyFromPeerDescriptor(targetPeerDescriptor)))
-        managedConnection.setPeerDescriptor(targetPeerDescriptor)
+        managedConnection.setRemotePeerDescriptor(targetPeerDescriptor)
         this.ongoingConnectRequests.set(keyFromPeerDescriptor(targetPeerDescriptor), managedConnection)
         return managedConnection
     }
 
-    private onServerSocketHandshakeRequest(peerDescriptor: PeerDescriptor, serverWebsocket: IConnection) {
-
-        const peerId = peerIdFromPeerDescriptor(peerDescriptor)
+    private onServerSocketHandshakeRequest(
+        sourcePeerDescriptor: PeerDescriptor, 
+        serverWebsocket: IConnection,
+        targetPeerDescriptor?: PeerDescriptor
+    ) {
+        const peerId = peerIdFromPeerDescriptor(sourcePeerDescriptor)
 
         if (this.ongoingConnectRequests.has(peerId.toKey())) {
-            const ongoingConnectReguest = this.ongoingConnectRequests.get(peerId.toKey())!
-            ongoingConnectReguest.attachImplementation(serverWebsocket)
-            ongoingConnectReguest.acceptHandshake()
-            this.ongoingConnectRequests.delete(peerId.toKey())
+            const ongoingConnectRequest = this.ongoingConnectRequests.get(peerId.toKey())!
+            ongoingConnectRequest.attachImplementation(serverWebsocket)
+            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                ongoingConnectRequest.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
+            } else {
+                ongoingConnectRequest.acceptHandshake()
+                this.ongoingConnectRequests.delete(peerId.toKey())
+            }
         } else {
-            const managedConnection = new ManagedConnection(this.localPeerDescriptor!, ConnectionType.WEBSOCKET_SERVER, undefined, serverWebsocket)
+            const managedConnection = new ManagedConnection(
+                this.localPeerDescriptor!,
+                ConnectionType.WEBSOCKET_SERVER,
+                undefined,
+                serverWebsocket,
+                targetPeerDescriptor
+            )
 
-            managedConnection.setPeerDescriptor(peerDescriptor)
+            managedConnection.setRemotePeerDescriptor(sourcePeerDescriptor)
 
-            if (this.onIncomingConnection(managedConnection)) {
+            if (targetPeerDescriptor && !areEqualPeerDescriptors(this.localPeerDescriptor!, targetPeerDescriptor)) {
+                managedConnection.rejectHandshake(HandshakeError.INVALID_TARGET_PEER_DESCRIPTOR)
+            } else if (this.onNewConnection(managedConnection)) {
                 managedConnection.acceptHandshake()
             } else {
-                managedConnection.rejectHandshake('Duplicate connection')
-                managedConnection.destroy()
+                managedConnection.rejectHandshake(HandshakeError.DUPLICATE_CONNECTION)
             }
         }
     }

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -11,7 +11,7 @@ import { ManagedConnection } from '../ManagedConnection'
 interface WebsocketConnectorRpcLocalConfig {
     canConnect: (peerDescriptor: PeerDescriptor) => boolean
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
-    onIncomingConnection: (connection: ManagedConnection) => boolean
+    onNewConnection: (connection: ManagedConnection) => boolean
     abortSignal: AbortSignal
 }
 
@@ -31,7 +31,7 @@ export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
                     return
                 }
                 const connection = this.config.connect(senderPeerDescriptor)
-                this.config.onIncomingConnection(connection)
+                this.config.onNewConnection(connection)
             })
             return { accepted: true }
         } else {

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -6,7 +6,7 @@ import { IWebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/Dh
 import { Logger } from '@streamr/utils'
 import * as Err from '../../helpers/errors'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Remote } from '../../dht/contact/Remote'
 
 const logger = new Logger(module)
@@ -22,7 +22,7 @@ export class WebsocketConnectorRpcRemote extends Remote<IWebsocketConnectorRpcCl
     }
 
     async requestConnection(ip: string, port: number): Promise<boolean> {
-        logger.trace(`Requesting WebSocket connection from ${keyFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
+        logger.trace(`Requesting WebSocket connection from ${getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())}`)
         const request: WebsocketConnectionRequest = {
             ip,
             port

package/src/dht/DhtNode.ts

@@ -33,7 +33,12 @@ import {
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { RandomContactList } from './contact/RandomContactList'
 import { Any } from '../proto/google/protobuf/any'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import {
+    areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../helpers/peerIdFromPeerDescriptor'
 import { Router } from './routing/Router'
 import { Finder, FindResult } from './find/Finder'
 import { StoreRpcLocal } from './store/StoreRpcLocal'
@@ -375,22 +380,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         } else {
             logger.trace('new connection not set to connections, there is already a connection with the peer ID')
         }
-        logger.trace('connected: ' + keyFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
+        logger.trace('connected: ' + getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
         this.emit('connected', peerDescriptor)
     }
 
     private onTransportDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
-        logger.trace('disconnected: ' + keyFromPeerDescriptor(peerDescriptor))
+        logger.trace('disconnected: ' + getNodeIdFromPeerDescriptor(peerDescriptor))
         this.connections.delete(keyFromPeerDescriptor(peerDescriptor))
         // only remove from bucket if we are on layer 0
         if (this.connectionManager) {
             this.bucket!.remove(peerDescriptor.kademliaId)
 
             if (gracefulLeave === true) {
-                logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
                 this.removeContact(peerDescriptor)
             } else {
-                logger.trace(keyFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
             }
         }
 
@@ -444,11 +449,12 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     private handleMessage(message: Message): void {
         if (message.serviceId === this.config.serviceId) {
-            logger.trace('callig this.handleMessageFromPeer ' + keyFromPeerDescriptor(message.sourceDescriptor!)
+            logger.trace('callig this.handleMessageFromPeer ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
                 + ' ' + message.serviceId + ' ' + message.messageId)
             this.rpcCommunicator?.handleMessageFromPeer(message)
         } else {
-            logger.trace('emit "message" ' + keyFromPeerDescriptor(message.sourceDescriptor!) + ' ' + message.serviceId + ' ' + message.messageId)
+            logger.trace('emit "message" ' + getNodeIdFromPeerDescriptor(message.sourceDescriptor!)
+                + ' ' + message.serviceId + ' ' + message.messageId)
             this.emit('message', message)
         }
     }
@@ -479,7 +485,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             return
         }
         this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
-        logger.trace(`Removed contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        logger.trace(`Removed contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         if (this.bucket!.count() === 0
             && !this.peerDiscovery!.isJoinOngoing()
             && this.config.entryPoints
@@ -501,14 +507,14 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             // Important to lock here, before the ping result is known
             this.connectionManager?.weakLockConnection(contact.getPeerDescriptor())
             if (this.connections.has(contact.getPeerId().toKey())) {
-                logger.trace(`Added new contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
+                logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
             } else {    // open connection by pinging
-                logger.trace('starting ping ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
+                logger.trace('starting ping ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
                 contact.ping().then((result) => {
                     if (result) {
-                        logger.trace(`Added new contact ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
+                        logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
                     } else {
-                        logger.trace('ping failed ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
+                        logger.trace('ping failed ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
                         this.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
                         this.removeContact(contact.getPeerDescriptor())
                         this.addClosestContactToBucket()
@@ -559,7 +565,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             return
         }
         if (!areEqualPeerDescriptors(contact, this.localPeerDescriptor!)) {
-            logger.trace(`Adding new contact ${keyFromPeerDescriptor(contact)}`)
+            logger.trace(`Adding new contact ${getNodeIdFromPeerDescriptor(contact)}`)
             const rpcRemote = new DhtNodeRpcRemote(
                 this.localPeerDescriptor!,
                 contact,
@@ -591,7 +597,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (!this.started || this.stopped) {
             return
         }
-        logger.trace(`Removing contact ${keyFromPeerDescriptor(contact)}`)
+        logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
         const peerId = peerIdFromPeerDescriptor(contact)
         this.bucket!.remove(peerId.value)
         this.neighborList!.removeContact(peerId)
@@ -722,8 +728,10 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.router!.stop()
         this.finder!.stop()
         this.peerDiscovery!.stop()
-        if (this.connectionManager) {
-            await this.connectionManager.stop()
+        if (this.config.transport === undefined) {
+            // if the transport was not given in config, the instance was created in start() and 
+            // this component is responsible for stopping it
+            await this.transport!.stop()
         }
         this.transport = undefined
         this.connectionManager = undefined

package/src/dht/DhtNodeRpcLocal.ts

@@ -1,7 +1,7 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
 import KBucket from 'k-bucket'
-import { keyFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
     ClosestPeersRequest,
@@ -48,7 +48,7 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     }
 
     async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
-        logger.trace('received ping request: ' + keyFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
+        logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {
             this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
         })
@@ -61,7 +61,7 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async leaveNotice(_request: LeaveNotice, context: ServerCallContext): Promise<Empty> {
         // TODO check signature??
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
-        logger.trace('received leave notice: ' + keyFromPeerDescriptor(sender))
+        logger.trace('received leave notice: ' + getNodeIdFromPeerDescriptor(sender))
         this.config.removeContact(sender)
         return {}
     }

package/src/dht/DhtNodeRpcRemote.ts

@@ -10,7 +10,7 @@ import { Logger } from '@streamr/utils'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { Remote } from './contact/Remote'
 import { PeerID } from '../helpers/PeerID'
-import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { ServiceID } from '../types/ServiceID'
 
 const logger = new Logger(module)
@@ -40,7 +40,7 @@ export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBuck
     }
 
     async getClosestPeers(kademliaId: Uint8Array): Promise<PeerDescriptor[]> {
-        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: ClosestPeersRequest = {
             kademliaId,
             requestId: v4()
@@ -55,7 +55,7 @@ export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBuck
     }
 
     async ping(): Promise<boolean> {
-        logger.trace(`Requesting ping on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting ping on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: PingRequest = {
             requestId: v4()
         }
@@ -66,13 +66,13 @@ export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBuck
                 return true
             }
         } catch (err) {
-            logger.trace(`ping failed on ${this.getServiceId()} to ${keyFromPeerDescriptor(this.getPeerDescriptor())}: ${err}`)
+            logger.trace(`ping failed on ${this.getServiceId()} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}: ${err}`)
         }
         return false
     }
 
     leaveNotice(): void {
-        logger.trace(`Sending leaveNotice on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Sending leaveNotice on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: LeaveNotice = {
             serviceId: this.getServiceId()
         }

package/src/dht/discovery/DiscoverySession.ts

@@ -8,7 +8,7 @@ import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { DhtNodeRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { SortedContactList } from '../contact/SortedContactList'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ServiceID } from '../../types/ServiceID'
 
 const logger = new Logger(module)
@@ -71,7 +71,7 @@ export class DiscoverySession {
         if (this.stopped) {
             return []
         }
-        logger.trace(`Getting closest peers from contact: ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
         this.config.neighborList.setContacted(contact.getPeerId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,6 +1,6 @@
 import { DiscoverySession } from './DiscoverySession'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
 import KBucket from 'k-bucket'
@@ -49,7 +49,7 @@ export class PeerDiscovery {
         this.joinCalled = true
         logger.debug(
             `Joining ${this.config.serviceId === 'layer0' ? 'The Streamr Network' : `Control Layer for ${this.config.serviceId}`}`
-            + ` via entrypoint ${keyFromPeerDescriptor(entryPointDescriptor)}`
+            + ` via entrypoint ${getNodeIdFromPeerDescriptor(entryPointDescriptor)}`
         )
         if (areEqualPeerDescriptors(entryPointDescriptor, this.config.localPeerDescriptor)) {
             return

package/src/dht/find/FindRpcLocal.ts

@@ -1,7 +1,7 @@
 import { Logger } from '@streamr/utils'
 import { PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { IFindRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { createRouteMessageAck } from '../routing/RouterRpcLocal'
 import { getPreviousPeer } from '../routing/getPreviousPeer'
 
@@ -26,8 +26,8 @@ export class FindRpcLocal implements IFindRpc {
         if (this.config.isMostLikelyDuplicate(routedMessage.requestId)) {
             return createRouteMessageAck(routedMessage, 'message given to routeFindRequest() service is likely a duplicate')
         }
-        const senderKey = keyFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
-        logger.trace(`Received routeFindRequest call from ${senderKey}`)
+        const senderId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
+        logger.trace(`Received routeFindRequest call from ${senderId}`)
         this.config.addContact(routedMessage.sourcePeer!, true)
         this.config.addToDuplicateDetector(routedMessage.requestId)
         return this.config.doRouteFindRequest(routedMessage)

package/src/dht/routing/FindRpcRemote.ts

@@ -1,6 +1,6 @@
 import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Remote } from '../contact/Remote'
 import { Logger } from '@streamr/utils'
 import { IFindRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
@@ -29,10 +29,10 @@ export class FindRpcRemote extends Remote<IFindRpcClient> {
         } catch (err) {
             const previousPeer = getPreviousPeer(params)
             const fromNode = previousPeer
-                ? keyFromPeerDescriptor(previousPeer)
-                : keyFromPeerDescriptor(params.sourcePeer!)
+                ? getNodeIdFromPeerDescriptor(previousPeer)
+                : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             // eslint-disable-next-line max-len
-            logger.debug(`Failed to send routeFindRequest message from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+            logger.debug(`Failed to send routeFindRequest message from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
             return false
         }
         return true