@streamr/dht 0.0.1-tatum.0

package/src/dht/discovery/PeerDiscovery.ts

@@ -0,0 +1,162 @@
+import { DiscoverySession } from './DiscoverySession'
+import { DhtPeer } from '../DhtPeer'
+import crypto from 'crypto'
+import * as Err from '../../helpers/errors'
+import { isSamePeerDescriptor, keyFromPeerDescriptor } 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 { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
+import { RandomContactList } from '../contact/RandomContactList'
+
+interface PeerDiscoveryConfig {
+    rpcCommunicator: RoutingRpcCommunicator
+    ownPeerDescriptor: PeerDescriptor
+    ownPeerId: PeerID
+    bucket: KBucket<DhtPeer>
+    connections: Map<PeerIDKey, DhtPeer>
+    neighborList: SortedContactList<DhtPeer>
+    randomPeers: RandomContactList<DhtPeer>
+    openInternetPeers: SortedContactList<DhtPeer>
+    joinNoProgressLimit: number
+    getClosestContactsLimit: number
+    serviceId: string
+    parallelism: number
+    joinTimeout: number
+    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
+    connectionManager?: ConnectionManager
+}
+
+const logger = new Logger(module)
+
+export class PeerDiscovery {
+    private readonly config: PeerDiscoveryConfig
+    private ongoingDiscoverySessions: Map<string, DiscoverySession> = new Map()
+    private stopped = false
+    private rejoinOngoing = false
+    private joinCalled = false
+
+    private rejoinTimeoutRef?: NodeJS.Timeout
+    private readonly abortController: AbortController
+
+    constructor(config: PeerDiscoveryConfig) {
+        this.config = config
+        this.abortController = new AbortController()
+    }
+
+    async joinDht(entryPointDescriptor: PeerDescriptor, doRandomJoin = true): Promise<void> {
+        if (this.stopped) {
+            return
+        }
+        this.joinCalled = true
+        logger.debug(
+            `Joining ${this.config.serviceId === 'layer0' ? 'The Streamr Network' : `Control Layer for ${this.config.serviceId}`}`
+            + ` via entrypoint ${keyFromPeerDescriptor(entryPointDescriptor)}`
+        )
+        if (isSamePeerDescriptor(entryPointDescriptor, this.config.ownPeerDescriptor)) {
+            return
+        }
+        this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+        this.config.addContact(entryPointDescriptor)
+        const closest = this.config.bucket.closest(this.config.ownPeerId!.value, this.config.getClosestContactsLimit)
+        this.config.neighborList.addContacts(closest)
+        const sessionOptions = {
+            bucket: this.config.bucket,
+            neighborList: this.config.neighborList!,
+            targetId: this.config.ownPeerId!.value,
+            ownPeerDescriptor: this.config.ownPeerDescriptor!,
+            serviceId: this.config.serviceId,
+            rpcCommunicator: this.config.rpcCommunicator!,
+            parallelism: this.config.parallelism,
+            noProgressLimit: this.config.joinNoProgressLimit,
+            newContactListener: (newPeer: DhtPeer) => this.config.addContact(newPeer.getPeerDescriptor()),
+            nodeName: this.config.ownPeerDescriptor.nodeName
+        }
+        const session = new DiscoverySession(sessionOptions)
+        const randomSession = doRandomJoin ? new DiscoverySession({
+            ...sessionOptions,
+            targetId: crypto.randomBytes(8),
+            nodeName: this.config.ownPeerDescriptor.nodeName + '-random'
+        }) : null
+        this.ongoingDiscoverySessions.set(session.sessionId, session)
+        if (randomSession) {
+            this.ongoingDiscoverySessions.set(randomSession.sessionId, randomSession)
+        }
+        try {
+            await session.findClosestNodes(this.config.joinTimeout)
+            if (randomSession) {
+                await randomSession.findClosestNodes(this.config.joinTimeout)
+            }
+            if (!this.stopped) {
+                if (this.config.bucket.count() === 0) {
+                    this.rejoinDht(entryPointDescriptor).catch(() => {})
+                } else {
+                    await scheduleAtInterval(() => this.getClosestPeersFromBucket(), 60000, true, this.abortController.signal)
+                }
+            }
+        } catch (_e) {
+            throw new Err.DhtJoinTimeout('join timed out')
+        } finally {
+            this.ongoingDiscoverySessions.delete(session.sessionId)
+            if (randomSession) {
+                this.ongoingDiscoverySessions.delete(randomSession.sessionId)
+            }
+            this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+        }
+    }
+
+    public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
+        if (this.stopped || this.rejoinOngoing) {
+            return
+        }
+        logger.debug(`Rejoining DHT ${this.config.serviceId} ${this.config.ownPeerDescriptor.nodeName}!`)
+        this.rejoinOngoing = true
+        try {
+            this.config.neighborList.clear()
+            await this.joinDht(entryPoint)
+            logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
+        } catch (err) {
+            logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
+            if (!this.stopped) {
+                setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.abortController.signal)
+            }
+        } finally {
+            this.rejoinOngoing = false
+        }
+    }
+
+    private async getClosestPeersFromBucket(): Promise<void> {
+        if (this.stopped) {
+            return
+        }
+        await Promise.allSettled(this.config.bucket.closest(this.config.ownPeerId.value, this.config.parallelism).map(async (peer: DhtPeer) => {
+            const contacts = await peer.getClosestPeers(this.config.ownPeerDescriptor.kademliaId!)
+            contacts.forEach((contact) => {
+                this.config.addContact(contact)
+            })
+        }))
+    }
+
+    public isJoinOngoing(): boolean {
+        return !this.joinCalled ? true : this.ongoingDiscoverySessions.size > 0
+    }
+
+    public isJoinCalled(): boolean {
+        return this.joinCalled
+    }
+
+    public stop(): void {
+        this.stopped = true
+        this.abortController.abort()
+        if (this.rejoinTimeoutRef) {
+            clearTimeout(this.rejoinTimeoutRef)
+            this.rejoinTimeoutRef = undefined
+        }
+        this.ongoingDiscoverySessions.forEach((session, _id) => {
+            session.stop()
+        })
+    }
+}

package/src/dht/find/RecursiveFindSession.ts

@@ -0,0 +1,178 @@
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { Logger } from '@streamr/utils'
+import EventEmitter from 'eventemitter3'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { DataEntry, FindMode, PeerDescriptor, RecursiveFindReport } from '../../proto/packages/dht/protos/DhtRpc'
+import { IRecursiveFindSessionService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { ITransport } from '../../transport/ITransport'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { Contact } from '../contact/Contact'
+import { SortedContactList } from '../contact/SortedContactList'
+import { RecursiveFindResult } from './RecursiveFinder'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+
+export interface RecursiveFindSessionEvents {
+    findCompleted: (results: PeerDescriptor[]) => void
+}
+
+const logger = new Logger(module)
+
+export interface RecursiveFindSessionConfig {
+    serviceId: string
+    rpcTransport: ITransport
+    kademliaIdToFind: Uint8Array
+    ownPeerID: PeerID
+    waitedRoutingPathCompletions: number
+    mode: FindMode
+}
+
+export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvents> implements IRecursiveFindSessionService {
+    private readonly serviceId: string
+    private readonly rpcTransport: ITransport
+    private readonly kademliaIdToFind: Uint8Array
+    private readonly ownPeerID: PeerID
+    private readonly waitedRoutingPathCompletions: number
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+    private readonly mode: FindMode
+    private results: SortedContactList<Contact>
+    private foundData: Map<string, DataEntry> = new Map()
+    private allKnownHops: Set<PeerIDKey> = new Set()
+    private reportedHops: Set<PeerIDKey> = new Set()
+    private reportFindCompletedTimeout?: NodeJS.Timeout
+    private findCompletedEmitted = false
+    private noCloserNodesReceivedCounter = 0
+
+    constructor(config: RecursiveFindSessionConfig) {
+        super()
+        this.serviceId = config.serviceId
+        this.rpcTransport = config.rpcTransport
+        this.kademliaIdToFind = config.kademliaIdToFind
+        this.ownPeerID = config.ownPeerID
+        this.waitedRoutingPathCompletions = config.waitedRoutingPathCompletions
+        this.results = new SortedContactList(PeerID.fromValue(this.kademliaIdToFind), 10, undefined, true)
+        this.mode = config.mode
+        this.rpcCommunicator = new ListeningRpcCommunicator(this.serviceId, this.rpcTransport, {
+            rpcRequestTimeout: 15000
+        })
+        this.rpcCommunicator.registerRpcNotification(RecursiveFindReport, 'reportRecursiveFindResult',
+            (req: RecursiveFindReport, context) => this.reportRecursiveFindResult(req, context))
+    }
+
+    private isFindCompleted(): boolean {
+        const unreportedHops: Set<PeerIDKey> = new Set(this.allKnownHops)
+        this.reportedHops.forEach((id) => {
+            unreportedHops.delete(id)
+        })
+        if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
+            if (this.mode === FindMode.DATA 
+                && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.waitedRoutingPathCompletions)) {
+                return true
+            } else if (this.mode === FindMode.DATA) {
+                return false
+            }
+            return true
+        }
+        return false
+    }
+
+    private hasNonStaleData(): boolean {
+        return Array.from(this.foundData.values()).some((entry) => entry.stale === false)
+    }
+
+    public doReportRecursiveFindResult(
+        routingPath: PeerDescriptor[],
+        nodes: PeerDescriptor[],
+        dataEntries: DataEntry[],
+        noCloserNodesFound?: boolean
+    ): void {
+        this.addKnownHops(routingPath)
+        if (routingPath.length >= 1) {
+            this.setHopAsReported(routingPath[routingPath.length - 1])
+        }
+        nodes.map((descriptor: PeerDescriptor) => {
+            this.results.addContact(new Contact(descriptor))
+        })
+        this.processFoundData(dataEntries)
+        if (noCloserNodesFound) {
+            this.onNoCloserPeersFound()
+        }
+    }
+
+    private addKnownHops(routingPath: PeerDescriptor[]) {
+        routingPath.forEach((desc) => {
+            const newPeerId = PeerID.fromValue(desc.kademliaId)
+            if (!this.ownPeerID.equals(newPeerId)) {
+                this.allKnownHops.add(newPeerId.toKey())
+            }
+        })
+    }
+
+    private setHopAsReported(desc: PeerDescriptor) {
+        const newPeerId = PeerID.fromValue(desc.kademliaId)
+        if (!this.ownPeerID.equals(newPeerId)) {
+            this.reportedHops.add(newPeerId.toKey())
+        }
+        if (this.isFindCompleted()) {
+            if (!this.findCompletedEmitted && this.isFindCompleted()) {
+                if (this.reportFindCompletedTimeout) {
+                    clearTimeout(this.reportFindCompletedTimeout)
+                    this.reportFindCompletedTimeout = undefined
+                }
+                this.emit('findCompleted', this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()))
+                this.findCompletedEmitted = true
+            }
+        }
+    }
+
+    private processFoundData(dataEntries: DataEntry[]): void {
+        dataEntries.forEach((entry) => {
+            const storerKey = keyFromPeerDescriptor(entry.storer!)
+            const existingEntry = this.foundData.get(storerKey)
+            if (!existingEntry || existingEntry.storerTime! < entry.storerTime! 
+                || (existingEntry.storerTime! <= entry.storerTime! && entry.deleted)) {
+                this.foundData.set(storerKey, entry)
+            }
+        })
+    }
+
+    private onNoCloserPeersFound(): void {
+        this.noCloserNodesReceivedCounter += 1
+        if (this.isFindCompleted()) {
+            this.emit('findCompleted', this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()))
+            this.findCompletedEmitted = true
+            if (this.reportFindCompletedTimeout) {
+                clearTimeout(this.reportFindCompletedTimeout)
+                this.reportFindCompletedTimeout = undefined
+            }
+        } else {
+            if (!this.reportFindCompletedTimeout && !this.findCompletedEmitted) {
+                this.reportFindCompletedTimeout = setTimeout(() => {
+                    if (!this.findCompletedEmitted) {
+                        this.emit('findCompleted', this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()))
+                        this.findCompletedEmitted = true
+                    }
+                }, 4000)
+            }
+        }
+    }
+
+    public async reportRecursiveFindResult(report: RecursiveFindReport, _context: ServerCallContext): Promise<Empty> {
+        logger.trace('recursiveFindReport arrived: ' + JSON.stringify(report))
+        this.doReportRecursiveFindResult(report.routingPath, report.nodes, report.dataEntries, report.noCloserNodesFound)
+        return {}
+    }
+
+    public getResults = (): RecursiveFindResult => ({
+        closestNodes: this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()),
+        dataEntries: (this.foundData && this.foundData.size > 0) ? Array.from(this.foundData.values()) : undefined
+    })
+
+    public stop(): void {
+        if (this.reportFindCompletedTimeout) {
+            clearTimeout(this.reportFindCompletedTimeout)
+            this.reportFindCompletedTimeout = undefined
+        }
+        this.emit('findCompleted', [])
+    }
+}

package/src/dht/find/RecursiveFinder.ts

@@ -0,0 +1,272 @@
+import {
+    DataEntry,
+    FindMode,
+    Message,
+    MessageType,
+    NodeType,
+    PeerDescriptor,
+    RecursiveFindRequest,
+    RouteMessageAck,
+    RouteMessageWrapper
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { createRouteMessageAck, RoutingErrors, IRouter } from '../routing/Router'
+import { RoutingMode } from '../routing/RoutingSession'
+import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
+import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
+import { RemoteRecursiveFindSession } from './RemoteRecursiveFindSession'
+import { v4 } from 'uuid'
+import { RecursiveFindSession, RecursiveFindSessionEvents } from './RecursiveFindSession'
+import { DhtPeer } from '../DhtPeer'
+import { ITransport } from '../../transport/ITransport'
+import { LocalDataStore } from '../store/LocalDataStore'
+import { IRoutingService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
+import { RecursiveFindSessionServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { SortedContactList } from '../contact/SortedContactList'
+
+interface RecursiveFinderConfig {
+    rpcCommunicator: RoutingRpcCommunicator
+    sessionTransport: ITransport
+    connections: Map<PeerIDKey, DhtPeer>
+    router: IRouter
+    ownPeerDescriptor: PeerDescriptor
+    ownPeerId: PeerID
+    serviceId: string
+    localDataStore: LocalDataStore
+    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
+    isPeerCloserToIdThanSelf: (peer1: PeerDescriptor, compareToId: PeerID) => boolean
+}
+
+interface RecursiveFinderFunc {
+    startRecursiveFind(idToFind: Uint8Array, findMode?: FindMode): Promise<RecursiveFindResult>
+}
+
+export interface IRecursiveFinder extends Pick<IRoutingService, 'findRecursively'>, RecursiveFinderFunc {}
+
+export interface RecursiveFindResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
+
+const logger = new Logger(module)
+
+export class RecursiveFinder implements IRecursiveFinder {
+
+    private readonly rpcCommunicator: RoutingRpcCommunicator
+    private readonly sessionTransport: ITransport
+    private readonly connections: Map<PeerIDKey, DhtPeer>
+    private readonly router: IRouter
+    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly ownPeerId: PeerID
+    private readonly serviceId: string
+    private readonly localDataStore: LocalDataStore
+    private readonly addContact: (contact: PeerDescriptor, setActive?: boolean) => void
+    private readonly isPeerCloserToIdThanSelf: (peer1: PeerDescriptor, compareToId: PeerID) => boolean
+    private ongoingSessions: Map<string, RecursiveFindSession> = new Map()
+    private stopped = false
+
+    constructor(config: RecursiveFinderConfig) {
+        this.rpcCommunicator = config.rpcCommunicator
+        this.sessionTransport = config.sessionTransport
+        this.connections = config.connections
+        this.router = config.router
+        this.ownPeerDescriptor = config.ownPeerDescriptor
+        this.ownPeerId = config.ownPeerId
+        this.serviceId = config.serviceId
+        this.localDataStore = config.localDataStore
+        this.addContact = config.addContact
+        this.isPeerCloserToIdThanSelf = config.isPeerCloserToIdThanSelf
+        this.rpcCommunicator!.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'findRecursively',
+            (routedMessage: RouteMessageWrapper) => this.findRecursively(routedMessage))
+    }
+
+    public async startRecursiveFind(
+        idToFind: Uint8Array,
+        findMode: FindMode = FindMode.NODE,
+        excludedPeer?: PeerDescriptor
+    ): Promise<RecursiveFindResult> {
+        if (this.stopped) {
+            return { closestNodes: [] }
+        }
+        const sessionId = v4()
+        const recursiveFindSession = new RecursiveFindSession({
+            serviceId: sessionId,
+            rpcTransport: this.sessionTransport,
+            kademliaIdToFind: idToFind,
+            ownPeerID: this.ownPeerId!,
+            waitedRoutingPathCompletions: this.connections.size > 1 ? 2 : 1,
+            mode: findMode
+        })
+        if (this.connections.size === 0) {
+            const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
+            recursiveFindSession.doReportRecursiveFindResult(
+                [this.ownPeerDescriptor!],
+                [this.ownPeerDescriptor!],
+                data ? Array.from(data.values()) : [],
+                true
+            )
+            return recursiveFindSession.getResults()
+        }
+        const routeMessage = this.wrapRecursiveFindRequest(idToFind, sessionId, findMode)
+        this.ongoingSessions.set(sessionId, recursiveFindSession)
+        try {
+            await runAndWaitForEvents3<RecursiveFindSessionEvents>(
+                [() => this.doFindRecursevily(routeMessage, excludedPeer)],
+                [[recursiveFindSession, 'findCompleted']],
+                15000
+            )
+        } catch (err) {
+            logger.debug(`doFindRecursively failed with error ${this.ownPeerDescriptor.nodeName} ${err}`)
+        }
+        this.findAndReportLocalData(idToFind, findMode, [], this.ownPeerDescriptor, sessionId)
+        this.ongoingSessions.delete(sessionId)
+        recursiveFindSession.stop()
+        return recursiveFindSession.getResults()
+    }
+
+    private wrapRecursiveFindRequest(idToFind: Uint8Array, sessionId: string, findMode: FindMode): RouteMessageWrapper {
+        const targetDescriptor: PeerDescriptor = {
+            kademliaId: idToFind,
+            type: NodeType.VIRTUAL
+        }
+        const request: RecursiveFindRequest = {
+            recursiveFindSessionId: sessionId,
+            findMode
+        }
+        const msg: Message = {
+            messageType: MessageType.RECURSIVE_FIND_REQUEST,
+            messageId: v4(),
+            serviceId: this.serviceId,
+            body: {
+                oneofKind: 'recursiveFindRequest',
+                recursiveFindRequest: request
+            }
+        }
+        const routeMessage: RouteMessageWrapper = {
+            message: msg,
+            requestId: v4(),
+            destinationPeer: targetDescriptor,
+            sourcePeer: this.ownPeerDescriptor,
+            reachableThrough: [],
+            routingPath: []
+        }
+        return routeMessage
+    }
+
+    private findAndReportLocalData(
+        idToFind: Uint8Array,
+        findMode: FindMode,
+        routingPath: PeerDescriptor[],
+        sourcePeer: PeerDescriptor,
+        sessionId: string
+    ): boolean {
+        if (findMode === FindMode.DATA) {
+            const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
+            if (data.size > 0) {
+                this.reportRecursiveFindResult(routingPath, sourcePeer, sessionId, [], data, true)
+                return true
+            }
+        }
+        return false
+    }
+
+    private findLocalData(idToFind: Uint8Array, findMode: FindMode): Map<PeerIDKey, DataEntry> | undefined {
+        if (findMode === FindMode.DATA) {
+            return this.localDataStore.getEntry(PeerID.fromValue(idToFind))
+        }
+        return undefined
+    }
+
+    private reportRecursiveFindResult(
+        routingPath: PeerDescriptor[],
+        targetPeerDescriptor: PeerDescriptor,
+        serviceId: string,
+        closestNodes: PeerDescriptor[],
+        data: Map<PeerIDKey, DataEntry> | undefined,
+        noCloserNodesFound: boolean = false
+    ): void {
+        const dataEntries = data ? Array.from(data.values(), DataEntry.create.bind(DataEntry)) : []
+        const isOwnPeerId = this.ownPeerId.equals(PeerID.fromValue(targetPeerDescriptor!.kademliaId))
+        if (isOwnPeerId && this.ongoingSessions.has(serviceId)) {
+            this.ongoingSessions.get(serviceId)!
+                .doReportRecursiveFindResult(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+        } else {
+            const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.sessionTransport, { rpcRequestTimeout: 15000 })
+            const remoteSession = new RemoteRecursiveFindSession(
+                this.ownPeerDescriptor,
+                targetPeerDescriptor,
+                toProtoRpcClient(new RecursiveFindSessionServiceClient(remoteCommunicator.getRpcClientTransport())),
+                serviceId
+            )
+            remoteSession.reportRecursiveFindResult(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+        }
+    }
+
+    private doFindRecursevily(routedMessage: RouteMessageWrapper, excludedPeer?: PeerDescriptor): RouteMessageAck {
+        if (this.stopped) {
+            return createRouteMessageAck(routedMessage, 'DhtNode Stopped')
+        }
+        const idToFind = PeerID.fromValue(routedMessage.destinationPeer!.kademliaId)
+        const msg = routedMessage.message
+        const recursiveFindRequest = msg?.body.oneofKind === 'recursiveFindRequest' ? msg.body.recursiveFindRequest : undefined
+        const closestPeersToDestination = this.getClosestConnections(routedMessage.destinationPeer!.kademliaId, 5)
+        const data = this.findLocalData(idToFind.value, recursiveFindRequest!.findMode)
+        if (this.ownPeerId!.equals(idToFind)) {
+            this.reportRecursiveFindResult(routedMessage.routingPath, routedMessage.sourcePeer!, recursiveFindRequest!.recursiveFindSessionId,
+                closestPeersToDestination, data, true)
+            return createRouteMessageAck(routedMessage)
+        }
+        const ack = this.router.doRouteMessage(routedMessage, RoutingMode.RECURSIVE_FIND, excludedPeer)
+        if (ack.error === RoutingErrors.NO_CANDIDATES_FOUND) {
+            logger.trace(`findRecursively Node ${this.ownPeerDescriptor.nodeName} found no candidates`)
+            this.reportRecursiveFindResult(routedMessage.routingPath, routedMessage.sourcePeer!, recursiveFindRequest!.recursiveFindSessionId,
+                closestPeersToDestination, data, true)
+        } else if (ack.error) {
+            return ack
+        } else {
+            const noCloserContactsFound = (
+                closestPeersToDestination.length > 0
+                && routedMessage.previousPeer
+                && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], idToFind)
+            )
+            this.reportRecursiveFindResult(routedMessage.routingPath, routedMessage.sourcePeer!, recursiveFindRequest!.recursiveFindSessionId,
+                closestPeersToDestination, data, noCloserContactsFound)
+        }
+        return ack
+    }
+
+    private getClosestConnections(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
+        const connectedPeers = Array.from(this.connections.values())
+        const closestPeers = new SortedContactList(
+            PeerID.fromValue(kademliaId),
+            limit,
+            undefined,
+            true,
+            undefined
+        )
+        closestPeers.addContacts(connectedPeers)
+        return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
+    }
+
+    // IRoutingService method
+    async findRecursively(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+        if (this.stopped) {
+            return createRouteMessageAck(routedMessage, 'findRecursively() service is not running')
+        } else if (this.router.checkDuplicate(routedMessage.requestId)) {
+            return createRouteMessageAck(routedMessage, 'message given to findRecursively() service is likely a duplicate')
+        }
+        const senderKey = keyFromPeerDescriptor(routedMessage.previousPeer || routedMessage.sourcePeer!)
+        logger.trace(`Node ${this.ownPeerId.toKey()} received findRecursively call from ${senderKey}`)
+        this.addContact(routedMessage.sourcePeer!, true)
+        this.router!.addToDuplicateDetector(routedMessage.requestId, keyFromPeerDescriptor(routedMessage.sourcePeer!))
+        return this.doFindRecursevily(routedMessage)
+    }
+
+    public stop(): void {
+        this.stopped = true
+        this.ongoingSessions.forEach((session, _id) => {
+            session.stop()
+        })
+        this.ongoingSessions.clear()
+    }
+}

package/src/dht/find/RemoteRecursiveFindSession.ts

@@ -0,0 +1,33 @@
+import {
+    DataEntry,
+    PeerDescriptor,
+    RecursiveFindReport
+} from '../../proto/packages/dht/protos/DhtRpc'
+import { IRecursiveFindSessionServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { Logger } from '@streamr/utils'
+import { Remote } from '../contact/Remote'
+
+const logger = new Logger(module)
+
+export class RemoteRecursiveFindSession extends Remote<IRecursiveFindSessionServiceClient> {
+
+    reportRecursiveFindResult(routingPath: PeerDescriptor[], closestNodes: PeerDescriptor[], 
+        dataEntries: DataEntry[], noCloserNodesFound: boolean): void {
+        
+        const report: RecursiveFindReport = {
+            routingPath,
+            nodes: closestNodes,
+            dataEntries,
+            noCloserNodesFound
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: this.ownPeerDescriptor,
+            targetDescriptor: this.peerDescriptor
+        }
+
+        this.client.reportRecursiveFindResult(report, options).catch((_e) => {
+            logger.trace('Failed to send RecursiveFindResult')
+        })
+    }
+}