@streamr/dht 100.0.0-testnet-two.4 → 100.0.0-testnet-three.0

package/src/connection/websocket/ServerWebsocket.ts

@@ -4,6 +4,7 @@ import { Message, connection as WsConnection } from 'websocket'
 import { Logger } from '@streamr/utils'
 import { Url } from 'url'
 import { CUSTOM_GOING_AWAY, GOING_AWAY } from './ClientWebsocket'
+import { createRandomConnectionId } from '../Connection'
 
 const logger = new Logger(module)
 
@@ -34,7 +35,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         this.onError = this.onError.bind(this)
 
         this.resourceURL = resourceURL
-        this.connectionId = new ConnectionID()
+        this.connectionId = createRandomConnectionId()
 
         socket.on('message', this.onMessage)
         socket.on('close', this.onClose)
@@ -82,6 +83,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         // If in an Karma / Electron test, use the NodeJS implementation
         // of Buffer instead of the browser polyfill
 
+        // TODO: no need to check this.socket as it is always defined when stopped is false?
         if (!this.stopped && this.socket) {
             if (typeof NodeJsBuffer !== 'undefined') {
                 this.socket.sendBytes(NodeJsBuffer.from(data))
@@ -104,6 +106,7 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
         }
     }
 
+    // TODO could rename to "closeSilently?"
     public destroy(): void {
         if (!this.stopped) {
             this.removeAllListeners()
@@ -119,9 +122,22 @@ export class ServerWebsocket extends EventEmitter<ConnectionEvents> implements I
     }
 
     public getRemoteAddress(): string {
+        // TODO: no need to check this.socket as it is always defined when stopped is false?
         if (!this.stopped && this.socket) {
             return this.socket.remoteAddress
         } else {
+            // TODO throw
+            logger.error('Tried to get the remoteAddress of a stopped connection')
+            return ''
+        }
+    }
+
+    public getRemoteIp(): string {
+        // TODO: no need to check this.socket as it is always defined when stopped is false?
+        if (!this.stopped && this.socket) {
+            return this.socket.socket.remoteAddress!
+        } else {
+            // TODO throw
             logger.error('Tried to get the remoteAddress of a stopped connection')
             return ''
         }

package/src/connection/websocket/WebsocketConnector.ts

@@ -12,14 +12,13 @@ import {
     WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { Logger, wait } from '@streamr/utils'
+import { ipv4ToNumber, Logger, wait } from '@streamr/utils'
 import { ManagedConnection } from '../ManagedConnection'
 import { WebsocketServer } from './WebsocketServer'
 import { sendConnectivityRequest } from '../connectivityChecker'
 import { NatType, PortRange, TlsCertificate } from '../ConnectionManager'
 import { ServerWebsocket } from './ServerWebsocket'
 import { Handshaker } from '../Handshaker'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ParsedUrlQuery } from 'querystring'
 import { range, sample } from 'lodash'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
@@ -29,7 +28,7 @@ import { AutoCertifierClientFacade } from './AutoCertifierClientFacade'
 import { attachConnectivityRequestHandler } from '../connectivityRequestHandler'
 import * as Err from '../../helpers/errors'
 import { Empty } from '../../proto/google/protobuf/empty'
-import { DhtAddress } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { version } from '../../../package.json'
 import { isCompatibleVersion } from '../../helpers/versionCompatibility'
 
@@ -46,7 +45,7 @@ const ENTRY_POINT_CONNECTION_ATTEMPTS = 5
 export interface WebsocketConnectorConfig {
     transport: ITransport
     onNewConnection: (connection: ManagedConnection) => boolean
-    hasConnection: (peerDescriptor: PeerDescriptor) => boolean
+    hasConnection: (nodeId: DhtAddress) => boolean
     portRange?: PortRange
     maxMessageSize?: number
     host?: string
@@ -90,12 +89,11 @@ export class WebsocketConnector {
     private registerLocalRpcMethods(config: WebsocketConnectorConfig) {
         const rpcLocal = new WebsocketConnectorRpcLocal({
             connect: (targetPeerDescriptor: PeerDescriptor) => this.connect(targetPeerDescriptor),
-            hasConnection: (targetPeerDescriptor: PeerDescriptor): boolean => {
-                const nodeId = getNodeIdFromPeerDescriptor(targetPeerDescriptor)
+            hasConnection: (nodeId: DhtAddress): boolean => {
                 if (this.connectingConnections.has(nodeId)
                     || this.connectingConnections.has(nodeId)
                     || this.ongoingConnectRequests.has(nodeId)
-                    || config.hasConnection(targetPeerDescriptor)
+                    || config.hasConnection(nodeId)
                 ) {
                     return true
                 } else {
@@ -167,7 +165,8 @@ export class WebsocketConnector {
         // TODO: this could throw if the server is not running
         const noServerConnectivityResponse: ConnectivityResponse = {
             host: '127.0.0.1',
-            natType: NatType.UNKNOWN
+            natType: NatType.UNKNOWN,
+            ipAddress: ipv4ToNumber('127.0.0.1')
         }
         if (this.abortController.signal.aborted) {
             return noServerConnectivityResponse
@@ -183,7 +182,9 @@ export class WebsocketConnector {
                         const preconfiguredConnectivityResponse: ConnectivityResponse = {
                             host: this.host!,
                             natType: NatType.OPEN_INTERNET,
-                            websocket: { host: this.host!, port: this.selectedPort!, tls: this.config.tlsCertificate !== undefined }
+                            websocket: { host: this.host!, port: this.selectedPort!, tls: this.config.tlsCertificate !== undefined },
+                            // TODO: maybe do a DNS lookup here?
+                            ipAddress: ipv4ToNumber('127.0.0.1')
                         }
                         return preconfiguredConnectivityResponse
                     } else {

package/src/connection/websocket/WebsocketConnectorRpcLocal.ts

@@ -7,10 +7,12 @@ import { IWebsocketConnectorRpc } from '../../proto/packages/dht/protos/DhtRpc.s
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { ManagedConnection } from '../ManagedConnection'
 import { Empty } from '../../proto/google/protobuf/empty'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress } from '../../identifiers'
 
 interface WebsocketConnectorRpcLocalConfig {
     connect: (targetPeerDescriptor: PeerDescriptor) => ManagedConnection
-    hasConnection: (targetPeerDescriptor: PeerDescriptor) => boolean
+    hasConnection: (nodeId: DhtAddress) => boolean
     onNewConnection: (connection: ManagedConnection) => boolean
     abortSignal: AbortSignal
 }
@@ -28,7 +30,7 @@ export class WebsocketConnectorRpcLocal implements IWebsocketConnectorRpc {
             return {}
         }
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        if (!this.config.hasConnection(senderPeerDescriptor)) {
+        if (!this.config.hasConnection(getNodeIdFromPeerDescriptor(senderPeerDescriptor))) {
             const connection = this.config.connect(senderPeerDescriptor)
             this.config.onNewConnection(connection)
         }

package/src/connection/websocket/WebsocketConnectorRpcRemote.ts

@@ -2,9 +2,9 @@ import {
     WebsocketConnectionRequest
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { RpcRemote } from '../../dht/contact/RpcRemote'
 import { WebsocketConnectorRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 

package/src/connection/websocket/WebsocketServer.ts

@@ -10,7 +10,7 @@ import { WebsocketServerStartError } from '../../helpers/errors'
 import { PortRange, TlsCertificate } from '../ConnectionManager'
 import { range } from 'lodash'
 import fs from 'fs'
-import { UUID } from '../../helpers/UUID'
+import { v4 as uuid } from 'uuid'
 
 const logger = new Logger(module)
 
@@ -77,7 +77,7 @@ export class WebsocketServer extends EventEmitter<ConnectionSourceEvents> {
                 this.httpServer = createHttpServer(requestListener)
             } else {
                 // TODO use config option or named constant?
-                const certificate = createSelfSignedCertificate('streamr-self-signed-' + new UUID().toString(), 1000)
+                const certificate = createSelfSignedCertificate('streamr-self-signed-' + uuid(), 1000)
                 this.httpServer = createHttpsServer({
                     key: certificate.serverKey,
                     cert: certificate.serverCert

package/src/dht/DhtNode.ts

@@ -1,56 +1,51 @@
-import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import {
+    Logger,
+    MetricsContext,
+    merge,
+    waitForCondition
+} from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
-import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
-import { PeerID } from '../helpers/PeerID'
+import { sample } from 'lodash'
+import { MarkRequired } from 'ts-essentials'
+import { ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../connection/ConnectorFacade'
+import { IceServer } from '../connection/webrtc/WebrtcConnector'
+import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { Any } from '../proto/google/protobuf/any'
 import {
     ClosestPeersRequest,
     ClosestPeersResponse,
-    LeaveNotice,
     ConnectivityResponse,
-    Message,
-    NodeType,
-    PeerDescriptor,
-    PingRequest,
-    PingResponse,
     DataEntry,
     ExternalFindDataRequest,
     ExternalFindDataResponse,
     ExternalStoreDataRequest,
     ExternalStoreDataResponse,
-    RecursiveOperation,
+    LeaveNotice,
+    Message,
+    PeerDescriptor,
+    PingRequest,
+    PingResponse,
+    RecursiveOperation
 } from '../proto/packages/dht/protos/DhtRpc'
-import { ITransport, TransportEvents } from '../transport/ITransport'
-import { ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
 import { ExternalApiRpcClient, StoreRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
-import {
-    Logger,
-    MetricsContext,
-    merge,
-    waitForCondition
-} from '@streamr/utils'
-import { Any } from '../proto/google/protobuf/any'
-import {
-    getNodeIdFromPeerDescriptor
-} from '../helpers/peerIdFromPeerDescriptor'
-import { Router } from './routing/Router'
-import { RecursiveOperationManager, RecursiveOperationResult } from './recursive-operation/RecursiveOperationManager'
-import { StoreManager } from './store/StoreManager'
-import { PeerDiscovery } from './discovery/PeerDiscovery'
-import { LocalDataStore } from './store/LocalDataStore'
-import { IceServer } from '../connection/webrtc/WebrtcConnector'
-import { ExternalApiRpcRemote } from './ExternalApiRpcRemote'
-import { UUID } from '../helpers/UUID'
-import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
-import { sample } from 'lodash'
-import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../connection/ConnectorFacade'
-import { MarkRequired } from 'ts-essentials'
+import { ITransport, TransportEvents } from '../transport/ITransport'
+import { RoutingRpcCommunicator } from '../transport/RoutingRpcCommunicator'
+import { ServiceID } from '../types/ServiceID'
 import { DhtNodeRpcLocal } from './DhtNodeRpcLocal'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 import { ExternalApiRpcLocal } from './ExternalApiRpcLocal'
+import { ExternalApiRpcRemote } from './ExternalApiRpcRemote'
 import { PeerManager } from './PeerManager'
-import { ServiceID } from '../types/ServiceID'
-import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
+import { PeerDiscovery } from './discovery/PeerDiscovery'
+import { RecursiveOperationManager, RecursiveOperationResult } from './recursive-operation/RecursiveOperationManager'
+import { Router } from './routing/Router'
+import { LocalDataStore } from './store/LocalDataStore'
+import { StoreManager } from './store/StoreManager'
 import { StoreRpcRemote } from './store/StoreRpcRemote'
+import { createPeerDescriptor } from '../helpers/createPeerDescriptor'
 
 export interface DhtNodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
@@ -79,7 +74,7 @@ export interface DhtNodeOptions {
     websocketHost?: string
     websocketPortRange?: PortRange
     websocketServerEnableTls?: boolean
-    peerId?: string
+    nodeId?: DhtAddress
 
     rpcRequestTimeout?: number
     iceServers?: IceServer[]
@@ -109,28 +104,12 @@ type StrictDhtNodeOptions = MarkRequired<DhtNodeOptions,
     'storeMaxTtl' |
     'networkConnectivityTimeout' |
     'storageRedundancyFactor' |
-    'metricsContext' |
-    'peerId'>
+    'metricsContext'>
 
 const logger = new Logger(module)
 
 export type Events = TransportEvents & DhtNodeEvents
 
-export const createPeerDescriptor = (msg?: ConnectivityResponse, peerId?: string): PeerDescriptor => {
-    let nodeId: DhtAddressRaw
-    if (msg) {
-        nodeId = (peerId !== undefined) ? getRawFromDhtAddress(peerId as DhtAddress) : PeerID.fromIp(msg.host).value
-    } else {
-        nodeId = getRawFromDhtAddress(peerId! as DhtAddress)
-    }
-    const nodeType = isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS
-    const ret: PeerDescriptor = { nodeId, type: nodeType }
-    if (msg && msg.websocket) {
-        ret.websocket = { host: msg.websocket.host, port: msg.websocket.port, tls: msg.websocket.tls }
-    }
-    return ret
-}
-
 export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     private readonly config: StrictDhtNodeOptions
@@ -162,10 +141,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             storeMaxTtl: 60000,
             networkConnectivityTimeout: 10000,
             storageRedundancyFactor: 5,
-            metricsContext: new MetricsContext(),
-            peerId: new UUID().toHex()
+            metricsContext: new MetricsContext()
         }, conf)
-        this.localDataStore = new LocalDataStore(this.config.storeMaxTtl) 
+        this.localDataStore = new LocalDataStore(this.config.storeMaxTtl)
         this.send = this.send.bind(this)
     }
 
@@ -214,7 +192,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                     min: this.config.peerDescriptor.websocket.port,
                     max: this.config.peerDescriptor.websocket.port
                 }
-            // If websocketPortRange is given, create ws server using it, websocketHost can be undefined
+                // If websocketPortRange is given, create ws server using it, websocketHost can be undefined
             } else if (this.config.websocketPortRange) {
                 connectorFacadeConfig.websocketHost = this.config.websocketHost
                 connectorFacadeConfig.websocketPortRange = this.config.websocketPortRange
@@ -334,10 +312,10 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             this.emit('connected', peerDescriptor)
         })
         this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => {
-            this.peerManager!.handleDisconnected(peerDescriptor, gracefulLeave)
+            this.peerManager!.handleDisconnected(getNodeIdFromPeerDescriptor(peerDescriptor), gracefulLeave)
             this.emit('disconnected', peerDescriptor, gracefulLeave)
         })
-        this.transport!.getAllConnectionPeerDescriptors().forEach((peer) => {
+        this.transport!.getConnections().forEach((peer) => {
             this.peerManager!.handleConnected(peer)
         })
     }
@@ -353,7 +331,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                     .map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
             },
             addNewContact: (contact: PeerDescriptor) => this.peerManager!.handleNewPeers([contact]),
-            removeContact: (contact: PeerDescriptor) => this.removeContact(contact)
+            removeContact: (nodeId: DhtAddress) => this.removeContact(nodeId)
         })
         this.rpcCommunicator!.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers',
             (req: ClosestPeersRequest, context) => dhtNodeRpcLocal.getClosestPeers(req, context))
@@ -362,7 +340,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.rpcCommunicator!.registerRpcNotification(LeaveNotice, 'leaveNotice',
             (_req: LeaveNotice, context) => dhtNodeRpcLocal.leaveNotice(context))
         const externalApiRpcLocal = new ExternalApiRpcLocal({
-            executeRecursiveOperation: (key: DhtAddress, operation: RecursiveOperation, excludedPeer: PeerDescriptor) => {
+            executeRecursiveOperation: (key: DhtAddress, operation: RecursiveOperation, excludedPeer: DhtAddress) => {
                 return this.executeRecursiveOperation(key, operation, excludedPeer)
             },
             storeDataToDht: (key: DhtAddress, data: Any, creator?: DhtAddress) => this.storeDataToDht(key, data, creator)
@@ -395,10 +373,10 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private generatePeerDescriptorCallBack(connectivityResponse: ConnectivityResponse) {
-        if (this.config.peerDescriptor) {
+        if (this.config.peerDescriptor !== undefined) {
             this.localPeerDescriptor = this.config.peerDescriptor
         } else {
-            this.localPeerDescriptor = createPeerDescriptor(connectivityResponse, this.config.peerId)
+            this.localPeerDescriptor = createPeerDescriptor(connectivityResponse, this.config.nodeId)
         }
         return this.localPeerDescriptor
     }
@@ -409,20 +387,20 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             limit).map((peer) => peer.getPeerDescriptor()
         )
     }
-    
+
     public getNodeId(): DhtAddress {
         return getNodeIdFromPeerDescriptor(this.localPeerDescriptor!)
     }
 
-    public getNumberOfNeighbors(): number {
-        return this.peerManager!.getNumberOfNeighbors()
+    public getNeighborCount(): number {
+        return this.peerManager!.getNeighborCount()
     }
 
-    public removeContact(contact: PeerDescriptor): void {
+    public removeContact(nodeId: DhtAddress): void {
         if (!this.started) {  // the stopped state is checked in PeerManager
             return
         }
-        this.peerManager!.handlePeerLeaving(contact)
+        this.peerManager!.handlePeerLeaving(nodeId)
     }
 
     public async send(msg: Message): Promise<void> {
@@ -439,11 +417,11 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         ) : []
     }
 
-    public async joinDht(entryPointDescriptors: PeerDescriptor[], doAdditionalRandomPeerDiscovery?: boolean, retry?: boolean): Promise<void> {
+    public async joinDht(entryPointDescriptors: PeerDescriptor[], doAdditionalDistantPeerDiscovery?: boolean, retry?: boolean): Promise<void> {
         if (!this.started) {
             throw new Error('Cannot join DHT before calling start() on DhtNode')
         }
-        await this.peerDiscovery!.joinDht(entryPointDescriptors, doAdditionalRandomPeerDiscovery, retry)
+        await this.peerDiscovery!.joinDht(entryPointDescriptors, doAdditionalDistantPeerDiscovery, retry)
     }
 
     // TODO make this private and unify the public API of find/fetch/store/delete methods
@@ -451,7 +429,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     public async executeRecursiveOperation(
         key: DhtAddress,
         operation: RecursiveOperation,
-        excludedPeer?: PeerDescriptor
+        excludedPeer?: DhtAddress
     ): Promise<RecursiveOperationResult> {
         return this.recursiveOperationManager!.execute(key, operation, excludedPeer)
     }
@@ -507,29 +485,28 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return this.localPeerDescriptor!
     }
 
-    public getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+    public getConnections(): PeerDescriptor[] {
         return Array.from(this.peerManager!.connections.values()).map((peer) => peer.getPeerDescriptor())
     }
 
-    // TODO rename to getNeighbors
-    public getAllNeighborPeerDescriptors(): PeerDescriptor[] {
-        return this.peerManager!.getNeighbors()
+    public getNeighbors(): PeerDescriptor[] {
+        return this.started ? this.peerManager!.getNeighbors() : []
     }
 
-    public getNumberOfConnections(): number {
-        return this.peerManager!.getNumberOfConnections()
+    public getConnectionCount(): number {
+        return this.peerManager!.getConnectionCount()
     }
 
-    public getNumberOfLocalLockedConnections(): number {
-        return this.connectionManager!.getNumberOfLocalLockedConnections()
+    public getLocalLockedConnectionCount(): number {
+        return this.connectionManager!.getLocalLockedConnectionCount()
     }
 
-    public getNumberOfRemoteLockedConnections(): number {
-        return this.connectionManager!.getNumberOfRemoteLockedConnections()
+    public getRemoteLockedConnectionCount(): number {
+        return this.connectionManager!.getRemoteLockedConnectionCount()
     }
 
-    public getNumberOfWeakLockedConnections(): number {
-        return this.connectionManager!.getNumberOfWeakLockedConnections()
+    public getWeakLockedConnectionCount(): number {
+        return this.connectionManager!.getWeakLockedConnectionCount()
     }
 
     public async waitForNetworkConnectivity(): Promise<void> {
@@ -537,7 +514,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             if (!this.peerManager) {
                 return false
             } else {
-                return (this.peerManager.getNumberOfConnections() > 0)
+                return (this.peerManager.getConnectionCount() > 0)
             }
         }, this.config.networkConnectivityTimeout, 100, this.abortController.signal)
     }

package/src/dht/DhtNodeRpcLocal.ts

@@ -1,6 +1,5 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
     ClosestPeersRequest,
@@ -11,13 +10,13 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import { IDhtNodeRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { DhtAddress, getDhtAddressFromRaw } from '../identifiers'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../identifiers'
 
 interface DhtNodeRpcLocalConfig {
     peerDiscoveryQueryBatchSize: number
     getClosestPeersTo: (nodeId: DhtAddress, limit: number) => PeerDescriptor[]
     addNewContact: (contact: PeerDescriptor) => void
-    removeContact: (contact: PeerDescriptor) => void
+    removeContact: (nodeId: DhtAddress) => void
 }
 
 const logger = new Logger(module)
@@ -53,8 +52,9 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async leaveNotice(context: ServerCallContext): Promise<Empty> {
         // TODO check signature??
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
-        logger.trace('received leave notice: ' + getNodeIdFromPeerDescriptor(sender))
-        this.config.removeContact(sender)
+        const senderNodeId = getNodeIdFromPeerDescriptor(sender)
+        logger.trace('received leave notice: ' + senderNodeId)
+        this.config.removeContact(senderNodeId)
         return {}
     }
 }

package/src/dht/DhtNodeRpcRemote.ts

@@ -1,8 +1,7 @@
 import { RpcCommunicator } from '@streamr/proto-rpc'
 import { Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
-import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
-import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
 import {
     ClosestPeersRequest,
     PeerDescriptor,
@@ -11,6 +10,7 @@ import {
 import { DhtNodeRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { ServiceID } from '../types/ServiceID'
 import { RpcRemote } from './contact/RpcRemote'
+import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 
 const logger = new Logger(module)
 
@@ -31,7 +31,7 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
         localPeerDescriptor: PeerDescriptor,
         peerDescriptor: PeerDescriptor,
         serviceId: ServiceID,
-        rpcCommunicator: RpcCommunicator,
+        rpcCommunicator: RpcCommunicator<DhtCallContext>,
         rpcRequestTimeout?: number
     ) {
         super(localPeerDescriptor, peerDescriptor, rpcCommunicator, DhtNodeRpcClient, rpcRequestTimeout)

package/src/dht/ExternalApiRpcLocal.ts

@@ -11,15 +11,14 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { RecursiveOperationResult } from './recursive-operation/RecursiveOperationManager'
 import { Any } from '../proto/google/protobuf/any'
-import { DhtAddress } from '../identifiers'
-import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { getDhtAddressFromRaw } from '../identifiers'
 
 interface ExternalApiRpcLocalConfig {
     executeRecursiveOperation: (
         targetId: DhtAddress,
         operation: RecursiveOperation,
-        excludedPeer: PeerDescriptor
+        excludedPeer: DhtAddress
     ) => Promise<RecursiveOperationResult>
     storeDataToDht: (
         key: DhtAddress,
@@ -41,7 +40,7 @@ export class ExternalApiRpcLocal implements IExternalApiRpc {
         const result = await this.config.executeRecursiveOperation(
             getDhtAddressFromRaw(findDataRequest.key),
             RecursiveOperation.FETCH_DATA,
-            senderPeerDescriptor
+            getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         )
         return ExternalFindDataResponse.create({ entries: result.dataEntries ?? [] })
     }