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

package/src/dht/DhtNodeRpcLocal.ts

@@ -0,0 +1,68 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { Logger } from '@streamr/utils'
+import KBucket from 'k-bucket'
+import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { Empty } from '../proto/google/protobuf/empty'
+import {
+    ClosestPeersRequest,
+    ClosestPeersResponse,
+    LeaveNotice,
+    PeerDescriptor,
+    PingRequest,
+    PingResponse
+} from '../proto/packages/dht/protos/DhtRpc'
+import { IDhtNodeRpc } from '../proto/packages/dht/protos/DhtRpc.server'
+import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
+import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
+
+interface DhtNodeRpcLocalConfig {
+    bucket: KBucket<DhtNodeRpcRemote>
+    serviceId: string
+    peerDiscoveryQueryBatchSize: number
+    addNewContact: (contact: PeerDescriptor) => void
+    removeContact: (contact: PeerDescriptor) => void
+}
+
+const logger = new Logger(module)
+
+export class DhtNodeRpcLocal implements IDhtNodeRpc {
+
+    private readonly config: DhtNodeRpcLocalConfig
+
+    constructor(config: DhtNodeRpcLocalConfig) {
+        this.config = config
+    }
+
+    async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
+        this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
+        const response = {
+            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.peerDiscoveryQueryBatchSize),
+            requestId: request.requestId
+        }
+        return response
+    }
+
+    private getClosestPeerDescriptors(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
+        const closestPeers = this.config.bucket.closest(kademliaId, limit)
+        return closestPeers.map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    }
+
+    async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
+        logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
+        setImmediate(() => {
+            this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
+        })
+        const response: PingResponse = {
+            requestId: request.requestId
+        }
+        return response
+    }
+
+    async leaveNotice(_request: 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)
+        return {}
+    }
+}

package/src/dht/{RemoteDhtNode.ts → DhtNodeRpcRemote.ts}

@@ -1,6 +1,7 @@
-import { IDhtRpcServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { IDhtNodeRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     ClosestPeersRequest,
+    LeaveNotice,
     PeerDescriptor,
     PingRequest
 } from '../proto/packages/dht/protos/DhtRpc'
@@ -9,7 +10,8 @@ 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)
 
@@ -19,25 +21,26 @@ export interface KBucketContact {
     vectorClock: number
 }
 
-export class RemoteDhtNode extends Remote<IDhtRpcServiceClient> implements KBucketContact {
+export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBucketContact {
 
     private static counter = 0
     public vectorClock: number
     public readonly id: Uint8Array
 
     constructor(
-        ownPeerDescriptor: PeerDescriptor,
+        localPeerDescriptor: PeerDescriptor,
         peerDescriptor: PeerDescriptor,
-        client: ProtoRpcClient<IDhtRpcServiceClient>,
-        serviceId: string
+        client: ProtoRpcClient<IDhtNodeRpcClient>,
+        serviceId: ServiceID,
+        rpcRequestTimeout?: number
     ) {
-        super(ownPeerDescriptor, peerDescriptor, serviceId, client)
+        super(localPeerDescriptor, peerDescriptor, serviceId, client, rpcRequestTimeout)
         this.id = this.getPeerId().value
-        this.vectorClock = RemoteDhtNode.counter++
+        this.vectorClock = DhtNodeRpcRemote.counter++
     }
 
     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()
@@ -52,28 +55,24 @@ export class RemoteDhtNode extends Remote<IDhtRpcServiceClient> 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()
         }
-        const options = this.formDhtRpcOptions({
-            timeout: 10000
-        })
+        const options = this.formDhtRpcOptions()
         try {
             const pong = await this.getClient().ping(request, options)
             if (pong.requestId === request.requestId) {
                 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
     }
 
-    /*
-    TODO remove or start using this method in NET-1131 
     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()
         }
@@ -83,7 +82,7 @@ export class RemoteDhtNode extends Remote<IDhtRpcServiceClient> implements KBuck
         this.getClient().leaveNotice(request, options).catch((e) => {
             logger.trace('Failed to send leaveNotice' + e)
         })
-    }*/
+    }
 
     getPeerId(): PeerID {
         return peerIdFromPeerDescriptor(this.getPeerDescriptor())

package/src/dht/ExternalApiRpcLocal.ts

@@ -0,0 +1,46 @@
+import { IExternalApiRpc } from '../proto/packages/dht/protos/DhtRpc.server'
+import {
+    ExternalFindDataRequest,
+    ExternalFindDataResponse,
+    ExternalStoreDataRequest,
+    ExternalStoreDataResponse,
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
+import { FindResult } from './find/Finder'
+import { Any } from '../proto/google/protobuf/any'
+
+interface ExternalApiRpcLocalConfig {
+    startFind: (idToFind: Uint8Array, fetchData: boolean, excludedPeer: PeerDescriptor) => Promise<FindResult>
+    storeDataToDht: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
+}
+
+export class ExternalApiRpcLocal implements IExternalApiRpc {
+
+    private readonly config: ExternalApiRpcLocalConfig
+
+    constructor(config: ExternalApiRpcLocalConfig) {
+        this.config = config
+    }
+
+    async externalFindData(findDataRequest: ExternalFindDataRequest, context: ServerCallContext): Promise<ExternalFindDataResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const result = await this.config.startFind(findDataRequest.kademliaId, true, senderPeerDescriptor)
+        if (result.dataEntries) {
+            return ExternalFindDataResponse.create({ dataEntries: result.dataEntries })
+        } else {
+            return ExternalFindDataResponse.create({ 
+                dataEntries: [],
+                error: 'Could not find data with the given key' 
+            })
+        }
+    }
+
+    async externalStoreData(request: ExternalStoreDataRequest): Promise<ExternalStoreDataResponse> {
+        const result = await this.config.storeDataToDht(request.key, request.data!)
+        return ExternalStoreDataResponse.create({
+            storers: result
+        })
+    }
+}

package/src/dht/ExternalApiRpcRemote.ts

@@ -1,19 +1,19 @@
 import { Any } from '../proto/google/protobuf/any'
-import { DataEntry, ExternalStoreDataRequest, FindDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+import { DataEntry, ExternalStoreDataRequest, ExternalFindDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { IExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { Remote } from './contact/Remote'
 
 export class ExternalApiRpcRemote extends Remote<IExternalApiRpcClient> {
 
-    async findData(idToFind: Uint8Array): Promise<DataEntry[]> {
-        const request: FindDataRequest = {
+    async externalFindData(idToFind: Uint8Array): Promise<DataEntry[]> {
+        const request: ExternalFindDataRequest = {
             kademliaId: idToFind
         }
         const options = this.formDhtRpcOptions({
             timeout: 10000
         })
         try {
-            const data = await this.getClient().findData(request, options)
+            const data = await this.getClient().externalFindData(request, options)
             return data.dataEntries
         } catch (err) {
             return []

package/src/dht/contact/Remote.ts

@@ -1,24 +1,51 @@
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { ServiceID } from '../../types/ServiceID'
+import { ConnectionType } from '../../connection/IConnection'
+import { expectedConnectionType } from '../../helpers/Connectivity'
+
+// Should connect directly to the server, timeout can be low
+const WEBSOCKET_CLIENT_TIMEOUT = 5000
+// Requires a WebsocketConnectionRequest to be routed to the client before the connection can be opened
+// takes a little bit longer than WEBSOCKET_CLIENT
+const WEBSOCKET_SERVER_TIMEOUT = 7500
+// WebRTC connections require lots of signalling to open and might take a longer time.
+const WEBRTC_TIMEOUT = 15000
+// default timeout for existing connections
+export const EXISTING_CONNECTION_TIMEOUT = 5000
+
+const getRpcTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): number => {
+    const connectionType = expectedConnectionType(localPeerDescriptor, remotePeerDescriptor)
+    if (connectionType === ConnectionType.WEBSOCKET_CLIENT) {
+        return WEBSOCKET_CLIENT_TIMEOUT
+    } else if (connectionType === ConnectionType.WEBSOCKET_SERVER) {
+        return WEBSOCKET_SERVER_TIMEOUT
+    } else if (connectionType === ConnectionType.WEBRTC) {
+        return WEBRTC_TIMEOUT
+    }
+    return WEBRTC_TIMEOUT
+}
 
 export abstract class Remote<T> {
 
     private readonly localPeerDescriptor: PeerDescriptor
     private readonly remotePeerDescriptor: PeerDescriptor
-    private readonly serviceId: string
+    private readonly serviceId: ServiceID
     private readonly client: ProtoRpcClient<T>
-
+    private readonly rpcTimeout?: number
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        serviceId: string,
-        client: ProtoRpcClient<T>
+        serviceId: ServiceID,
+        client: ProtoRpcClient<T>,
+        rpcTimeout?: number
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.remotePeerDescriptor = remotePeerDescriptor
         this.client = client
         this.serviceId = serviceId
+        this.rpcTimeout = rpcTimeout
     }
 
     getPeerDescriptor(): PeerDescriptor {
@@ -41,6 +68,7 @@ export abstract class Remote<T> {
         return {
             sourceDescriptor: this.localPeerDescriptor,
             targetDescriptor: this.remotePeerDescriptor,
+            timeout: this.rpcTimeout ?? getRpcTimeout(this.localPeerDescriptor, this.remotePeerDescriptor),
             ...opts
         }
     }

package/src/dht/contact/SortedContactList.ts

@@ -4,7 +4,7 @@ import { ContactList, ContactState } from './ContactList'
 
 export class SortedContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
 
-    private allowOwnPeerId: boolean
+    private allowLocalPeerId: boolean
     private peerIdDistanceLimit?: PeerID
     private excludedPeerIDs?: PeerID[]
 
@@ -12,13 +12,13 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         ownId: PeerID,
         maxSize: number,
         defaultContactQueryLimit?: number,
-        allowOwnPeerId = false,
+        allowLocalPeerId = false,
         peerIdDistanceLimit?: PeerID,
         excludedPeerIDs?: PeerID[]
     ) {
         super(ownId, maxSize, defaultContactQueryLimit)
         this.compareIds = this.compareIds.bind(this)
-        this.allowOwnPeerId = allowOwnPeerId
+        this.allowLocalPeerId = allowLocalPeerId
         this.peerIdDistanceLimit = peerIdDistanceLimit
         this.excludedPeerIDs = excludedPeerIDs
     }
@@ -37,7 +37,7 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
             return
         }
         
-        if ((!this.allowOwnPeerId && this.ownId.equals(contact.getPeerId())) ||
+        if ((!this.allowLocalPeerId && this.ownId.equals(contact.getPeerId())) ||
             (this.peerIdDistanceLimit !== undefined && this.compareIds(this.peerIdDistanceLimit, contact.getPeerId()) < 0)) {
             return
         }

package/src/dht/discovery/DiscoverySession.ts

@@ -5,10 +5,11 @@ import KBucket from 'k-bucket'
 import { v4 } from 'uuid'
 import { PeerID } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { DhtRpcServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { DhtNodeRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { SortedContactList } from '../contact/SortedContactList'
-import { RemoteDhtNode } from '../RemoteDhtNode'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { ServiceID } from '../../types/ServiceID'
 
 const logger = new Logger(module)
 
@@ -17,15 +18,16 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    bucket: KBucket<RemoteDhtNode>
-    neighborList: SortedContactList<RemoteDhtNode>
+    bucket: KBucket<DhtNodeRpcRemote>
+    neighborList: SortedContactList<DhtNodeRpcRemote>
     targetId: Uint8Array
-    ownPeerDescriptor: PeerDescriptor
-    serviceId: string
+    localPeerDescriptor: PeerDescriptor
+    serviceId: ServiceID
     rpcCommunicator: RpcCommunicator
     parallelism: number
     noProgressLimit: number
-    newContactListener?: (remoteDhtNode: RemoteDhtNode) => void
+    newContactListener?: (rpcRemote: DhtNodeRpcRemote) => void
+    rpcRequestTimeout?: number
 }
 
 export class DiscoverySession {
@@ -47,28 +49,29 @@ export class DiscoverySession {
             return
         }
         contacts.forEach((contact) => {
-            if (!areEqualPeerDescriptors(contact, this.config.ownPeerDescriptor)) {
-                const remoteDhtNode = new RemoteDhtNode(
-                    this.config.ownPeerDescriptor,
+            if (!areEqualPeerDescriptors(contact, this.config.localPeerDescriptor)) {
+                const rpcRemote = new DhtNodeRpcRemote(
+                    this.config.localPeerDescriptor,
                     contact,
-                    toProtoRpcClient(new DhtRpcServiceClient(this.config.rpcCommunicator.getRpcClientTransport())),
-                    this.config.serviceId
+                    toProtoRpcClient(new DhtNodeRpcClient(this.config.rpcCommunicator.getRpcClientTransport())),
+                    this.config.serviceId,
+                    this.config.rpcRequestTimeout
                 )
                 if (this.config.newContactListener) {
-                    this.config.newContactListener(remoteDhtNode)
+                    this.config.newContactListener(rpcRemote)
                 }
-                if (!this.config.neighborList.getContact(remoteDhtNode.getPeerId())) {
-                    this.config.neighborList.addContact(remoteDhtNode)
+                if (!this.config.neighborList.getContact(rpcRemote.getPeerId())) {
+                    this.config.neighborList.addContact(rpcRemote)
                 }
             }
         })
     }
 
-    private async getClosestPeersFromContact(contact: RemoteDhtNode): Promise<PeerDescriptor[]> {
+    private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
         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)
@@ -90,7 +93,7 @@ export class DiscoverySession {
         }
     }
 
-    private onClosestPeersRequestFailed(peer: RemoteDhtNode) {
+    private onClosestPeersRequestFailed(peer: DhtNodeRpcRemote) {
         if (!this.ongoingClosestPeersRequests.has(peer.getPeerId().toKey())) {
             return
         }
@@ -104,7 +107,7 @@ export class DiscoverySession {
             return
         }
         const uncontacted = this.config.neighborList.getUncontactedContacts(this.config.parallelism)
-        if (uncontacted.length < 1 || this.noProgressCounter >= this.config.noProgressLimit) {
+        if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
             this.emitter.emit('discoveryCompleted')
             this.stopped = true
             return
@@ -125,8 +128,8 @@ export class DiscoverySession {
         }
     }
 
-    public async findClosestNodes(timeout: number): Promise<SortedContactList<RemoteDhtNode>> {
-        if (this.config.neighborList.getUncontactedContacts(this.config.parallelism).length < 1) {
+    public async findClosestNodes(timeout: number): Promise<SortedContactList<DhtNodeRpcRemote>> {
+        if (this.config.neighborList.getUncontactedContacts(this.config.parallelism).length === 0) {
             logger.trace('getUncontactedContacts length was 0 in beginning of discovery, this.neighborList.size: '
                 + this.config.neighborList.getSize())
             return this.config.neighborList

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,31 +1,28 @@
 import { DiscoverySession } from './DiscoverySession'
-import { RemoteDhtNode } from '../RemoteDhtNode'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+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'
 import { SortedContactList } from '../contact/SortedContactList'
 import { ConnectionManager } from '../../connection/ConnectionManager'
-import { PeerIDKey } from '../../helpers/PeerID'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RandomContactList } from '../contact/RandomContactList'
 import { createRandomKademliaId } from '../../helpers/kademliaId'
+import { ServiceID } from '../../types/ServiceID'
 
 interface PeerDiscoveryConfig {
     rpcCommunicator: RoutingRpcCommunicator
-    ownPeerDescriptor: PeerDescriptor
-    bucket: KBucket<RemoteDhtNode>
-    connections: Map<PeerIDKey, RemoteDhtNode>
-    neighborList: SortedContactList<RemoteDhtNode>
-    randomPeers: RandomContactList<RemoteDhtNode>
-    openInternetPeers: SortedContactList<RemoteDhtNode>
+    localPeerDescriptor: PeerDescriptor
+    bucket: KBucket<DhtNodeRpcRemote>
+    neighborList: SortedContactList<DhtNodeRpcRemote>
     joinNoProgressLimit: number
     peerDiscoveryQueryBatchSize: number
-    serviceId: string
+    serviceId: ServiceID
     parallelism: number
     joinTimeout: number
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     connectionManager?: ConnectionManager
+    rpcRequestTimeout?: number
 }
 
 const logger = new Logger(module)
@@ -52,14 +49,14 @@ 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.ownPeerDescriptor)) {
+        if (areEqualPeerDescriptors(entryPointDescriptor, this.config.localPeerDescriptor)) {
             return
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
         this.config.addContact(entryPointDescriptor)
-        const targetId = peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value
+        const targetId = peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value
         const closest = this.config.bucket.closest(targetId, this.config.peerDiscoveryQueryBatchSize)
         this.config.neighborList.addContacts(closest)
         const sessions = [this.createSession(targetId)]
@@ -76,12 +73,12 @@ export class PeerDiscovery {
             bucket: this.config.bucket,
             neighborList: this.config.neighborList,
             targetId,
-            ownPeerDescriptor: this.config.ownPeerDescriptor,
+            localPeerDescriptor: this.config.localPeerDescriptor,
             serviceId: this.config.serviceId,
             rpcCommunicator: this.config.rpcCommunicator,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
-            newContactListener: (newPeer: RemoteDhtNode) => this.config.addContact(newPeer.getPeerDescriptor())
+            newContactListener: (newPeer: DhtNodeRpcRemote) => this.config.addContact(newPeer.getPeerDescriptor())
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -139,9 +136,9 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
-        const nodes = this.config.bucket.closest(peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value, this.config.parallelism)
-        await Promise.allSettled(nodes.map(async (peer: RemoteDhtNode) => {
-            const contacts = await peer.getClosestPeers(this.config.ownPeerDescriptor.kademliaId)
+        const nodes = this.config.bucket.closest(peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value, this.config.parallelism)
+        await Promise.allSettled(nodes.map(async (peer: DhtNodeRpcRemote) => {
+            const contacts = await peer.getClosestPeers(this.config.localPeerDescriptor.kademliaId)
             contacts.forEach((contact) => {
                 this.config.addContact(contact)
             })

package/src/dht/find/FindRpcLocal.ts

@@ -0,0 +1,35 @@
+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 { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { createRouteMessageAck } from '../routing/RouterRpcLocal'
+import { getPreviousPeer } from '../routing/getPreviousPeer'
+
+const logger = new Logger(module)
+
+interface FindRpcLocalConfig {
+    doRouteFindRequest: (routedMessage: RouteMessageWrapper) => RouteMessageAck
+    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
+    isMostLikelyDuplicate: (requestId: string) => boolean
+    addToDuplicateDetector: (requestId: string) => void
+}
+
+export class FindRpcLocal implements IFindRpc {
+
+    private readonly config: FindRpcLocalConfig
+
+    constructor(config: FindRpcLocalConfig) {
+        this.config = config
+    }
+
+    async routeFindRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+        if (this.config.isMostLikelyDuplicate(routedMessage.requestId)) {
+            return createRouteMessageAck(routedMessage, 'message given to routeFindRequest() service is likely a duplicate')
+        }
+        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)
+    }
+}