@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/dht/{RemoteExternalApi.ts → ExternalApiRpcRemote.ts}

@@ -1,14 +1,13 @@
 import { Any } from '../proto/google/protobuf/any'
 import { DataEntry, ExternalStoreDataRequest, FindDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
-import { IExternalApiServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { IExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import { Remote } from './contact/Remote'
 
-export class RemoteExternalApi extends Remote<IExternalApiServiceClient> {
+export class ExternalApiRpcRemote extends Remote<IExternalApiRpcClient> {
 
     async findData(idToFind: Uint8Array): Promise<DataEntry[]> {
         const request: FindDataRequest = {
-            kademliaId: idToFind,
-            requestor: this.getLocalPeerDescriptor(),
+            kademliaId: idToFind
         }
         const options = this.formDhtRpcOptions({
             timeout: 10000

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

@@ -1,7 +1,6 @@
 import { IDhtRpcServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     ClosestPeersRequest,
-    LeaveNotice,
     PeerDescriptor,
     PingRequest
 } from '../proto/packages/dht/protos/DhtRpc'
@@ -9,7 +8,8 @@ import { v4 } from 'uuid'
 import { Logger } from '@streamr/utils'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { Remote } from './contact/Remote'
-import { PeerID, peerIdFromPeerDescriptor } from '../exports'
+import { PeerID } from '../helpers/PeerID'
+import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -19,7 +19,7 @@ export interface KBucketContact {
     vectorClock: number
 }
 
-export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketContact {
+export class RemoteDhtNode extends Remote<IDhtRpcServiceClient> implements KBucketContact {
 
     private static counter = 0
     public vectorClock: number
@@ -33,11 +33,11 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
     ) {
         super(ownPeerDescriptor, peerDescriptor, serviceId, client)
         this.id = this.getPeerId().value
-        this.vectorClock = DhtPeer.counter++
+        this.vectorClock = RemoteDhtNode.counter++
     }
 
     async getClosestPeers(kademliaId: Uint8Array): Promise<PeerDescriptor[]> {
-        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${this.getPeerId().toKey()}`)
+        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: ClosestPeersRequest = {
             kademliaId,
             requestId: v4()
@@ -52,7 +52,7 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
     }
 
     async ping(): Promise<boolean> {
-        logger.trace(`Requesting ping on ${this.getServiceId()} from ${this.getPeerId().toKey()}`)
+        logger.trace(`Requesting ping on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: PingRequest = {
             requestId: v4()
         }
@@ -65,13 +65,15 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
                 return true
             }
         } catch (err) {
-            logger.trace(`ping failed on ${this.getServiceId()} to ${this.getPeerId().toKey()}: ${err}`)
+            logger.trace(`ping failed on ${this.getServiceId()} to ${keyFromPeerDescriptor(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 ${this.getPeerId().toKey()}`)
+        logger.trace(`Sending leaveNotice on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: LeaveNotice = {
             serviceId: this.getServiceId()
         }
@@ -81,7 +83,7 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
         this.getClient().leaveNotice(request, options).catch((e) => {
             logger.trace('Failed to send leaveNotice' + e)
         })
-    }
+    }*/
 
     getPeerId(): PeerID {
         return peerIdFromPeerDescriptor(this.getPeerDescriptor())

package/src/dht/contact/ContactList.ts

@@ -39,10 +39,6 @@ export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmi
         return this.contactsById.get(id.toKey())!
     }
 
-    public hasContact(id: PeerID): boolean {
-        return this.contactsById.has(id.toKey())
-    }
-
     public getSize(): number {
         return this.contactIds.length
     }

package/src/dht/contact/RandomContactList.ts

@@ -37,10 +37,6 @@ export class RandomContactList<C extends { getPeerId: () => PeerID }> extends Co
         }
     }
 
-    addContacts(contacts: C[]): void {
-        contacts.forEach((contact) => this.addContact(contact))
-    }
-
     removeContact(id: PeerID): boolean {
         if (this.contactsById.has(id.toKey())) {
             const removed = this.contactsById.get(id.toKey())!.contact

package/src/dht/contact/SortedContactList.ts

@@ -129,10 +129,6 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         return distance1 - distance2
     }
 
-    public getStringIds(): string[] {
-        return this.contactIds.map((peerId) => peerId.toKey())
-    }
-
     public removeContact(id: PeerID): boolean {
         if (this.contactsById.has(id.toKey())) {
             const removed = this.contactsById.get(id.toKey())!.contact
@@ -156,12 +152,4 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     public getAllContacts(): C[] {
         return this.contactIds.map((peerId) => this.contactsById.get(peerId.toKey())!.contact)
     }
-
-    public getMaxSize(): number {
-        return this.maxSize
-    }
-
-    public setAllAsUncontacted(): void {
-        this.contactsById.forEach((contact) => contact.contacted = false)
-    }
 }

package/src/dht/discovery/DiscoverySession.ts

@@ -7,8 +7,8 @@ import { PeerID } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { DhtRpcServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { SortedContactList } from '../contact/SortedContactList'
-import { DhtPeer } from '../DhtPeer'
-import { peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { RemoteDhtNode } from '../RemoteDhtNode'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -17,16 +17,15 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    bucket: KBucket<DhtPeer>
-    neighborList: SortedContactList<DhtPeer>
+    bucket: KBucket<RemoteDhtNode>
+    neighborList: SortedContactList<RemoteDhtNode>
     targetId: Uint8Array
     ownPeerDescriptor: PeerDescriptor
     serviceId: string
     rpcCommunicator: RpcCommunicator
     parallelism: number
     noProgressLimit: number
-    newContactListener?: (dhtPeer: DhtPeer) => void
-    nodeName?: string
+    newContactListener?: (remoteDhtNode: RemoteDhtNode) => void
 }
 
 export class DiscoverySession {
@@ -38,11 +37,9 @@ export class DiscoverySession {
     private noProgressCounter = 0
     private ongoingClosestPeersRequests: Set<string> = new Set()
     private readonly config: DiscoverySessionConfig
-    private readonly ownPeerId: PeerID
 
     constructor(config: DiscoverySessionConfig) {
         this.config = config
-        this.ownPeerId = peerIdFromPeerDescriptor(config.ownPeerDescriptor)
     }
 
     private addNewContacts(contacts: PeerDescriptor[]): void {
@@ -50,28 +47,28 @@ export class DiscoverySession {
             return
         }
         contacts.forEach((contact) => {
-            const dhtPeer = new DhtPeer(
-                this.config.ownPeerDescriptor,
-                contact,
-                toProtoRpcClient(new DhtRpcServiceClient(this.config.rpcCommunicator.getRpcClientTransport())),
-                this.config.serviceId
-            )
-            if (!dhtPeer.getPeerId().equals(this.ownPeerId)) {
+            if (!areEqualPeerDescriptors(contact, this.config.ownPeerDescriptor)) {
+                const remoteDhtNode = new RemoteDhtNode(
+                    this.config.ownPeerDescriptor,
+                    contact,
+                    toProtoRpcClient(new DhtRpcServiceClient(this.config.rpcCommunicator.getRpcClientTransport())),
+                    this.config.serviceId
+                )
                 if (this.config.newContactListener) {
-                    this.config.newContactListener(dhtPeer)
+                    this.config.newContactListener(remoteDhtNode)
                 }
-                if (!this.config.neighborList.getContact(dhtPeer.getPeerId())) {
-                    this.config.neighborList.addContact(dhtPeer)
+                if (!this.config.neighborList.getContact(remoteDhtNode.getPeerId())) {
+                    this.config.neighborList.addContact(remoteDhtNode)
                 }
             }
         })
     }
 
-    private async getClosestPeersFromContact(contact: DhtPeer): Promise<PeerDescriptor[]> {
+    private async getClosestPeersFromContact(contact: RemoteDhtNode): Promise<PeerDescriptor[]> {
         if (this.stopped) {
             return []
         }
-        logger.trace(`Getting closest peers from contact: ${contact.getPeerId().toKey()}`)
+        logger.trace(`Getting closest peers from contact: ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
         this.config.neighborList.setContacted(contact.getPeerId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
@@ -93,7 +90,7 @@ export class DiscoverySession {
         }
     }
 
-    private onClosestPeersRequestFailed(peer: DhtPeer, _exception: Error) {
+    private onClosestPeersRequestFailed(peer: RemoteDhtNode) {
         if (!this.ongoingClosestPeersRequests.has(peer.getPeerId().toKey())) {
             return
         }
@@ -120,7 +117,7 @@ export class DiscoverySession {
             // eslint-disable-next-line promise/catch-or-return
             this.getClosestPeersFromContact(nextPeer)
                 .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getPeerId(), contacts))
-                .catch((err) => this.onClosestPeersRequestFailed(nextPeer, err))
+                .catch(() => this.onClosestPeersRequestFailed(nextPeer))
                 .finally(() => {
                     this.outgoingClosestPeersRequestsCounter--
                     this.findMoreContacts()
@@ -128,7 +125,7 @@ export class DiscoverySession {
         }
     }
 
-    public async findClosestNodes(timeout: number): Promise<SortedContactList<DhtPeer>> {
+    public async findClosestNodes(timeout: number): Promise<SortedContactList<RemoteDhtNode>> {
         if (this.config.neighborList.getUncontactedContacts(this.config.parallelism).length < 1) {
             logger.trace('getUncontactedContacts length was 0 in beginning of discovery, this.neighborList.size: '
                 + this.config.neighborList.getSize())

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,27 +1,26 @@
 import { DiscoverySession } from './DiscoverySession'
-import { DhtPeer } from '../DhtPeer'
-import crypto from 'crypto'
-import { isSamePeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { RemoteDhtNode } from '../RemoteDhtNode'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, 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 { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { PeerIDKey } from '../../helpers/PeerID'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RandomContactList } from '../contact/RandomContactList'
+import { createRandomKademliaId } from '../../helpers/kademliaId'
 
 interface PeerDiscoveryConfig {
     rpcCommunicator: RoutingRpcCommunicator
     ownPeerDescriptor: PeerDescriptor
-    ownPeerId: PeerID
-    bucket: KBucket<DhtPeer>
-    connections: Map<PeerIDKey, DhtPeer>
-    neighborList: SortedContactList<DhtPeer>
-    randomPeers: RandomContactList<DhtPeer>
-    openInternetPeers: SortedContactList<DhtPeer>
+    bucket: KBucket<RemoteDhtNode>
+    connections: Map<PeerIDKey, RemoteDhtNode>
+    neighborList: SortedContactList<RemoteDhtNode>
+    randomPeers: RandomContactList<RemoteDhtNode>
+    openInternetPeers: SortedContactList<RemoteDhtNode>
     joinNoProgressLimit: number
-    getClosestContactsLimit: number
+    peerDiscoveryQueryBatchSize: number
     serviceId: string
     parallelism: number
     joinTimeout: number
@@ -32,12 +31,11 @@ interface PeerDiscoveryConfig {
 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
     private recoveryIntervalStarted = false
@@ -47,8 +45,8 @@ export class PeerDiscovery {
         this.abortController = new AbortController()
     }
 
-    async joinDht(entryPointDescriptor: PeerDescriptor, doRandomJoin = true, retry = true): Promise<void> {
-        if (this.stopped) {
+    async joinDht(entryPointDescriptor: PeerDescriptor, doAdditionalRandomPeerDiscovery = true, retry = true): Promise<void> {
+        if (this.isStopped()) {
             return
         }
         this.joinCalled = true
@@ -56,44 +54,48 @@ export class PeerDiscovery {
             `Joining ${this.config.serviceId === 'layer0' ? 'The Streamr Network' : `Control Layer for ${this.config.serviceId}`}`
             + ` via entrypoint ${keyFromPeerDescriptor(entryPointDescriptor)}`
         )
-        if (isSamePeerDescriptor(entryPointDescriptor, this.config.ownPeerDescriptor)) {
+        if (areEqualPeerDescriptors(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)
+        const targetId = peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value
+        const closest = this.config.bucket.closest(targetId, this.config.peerDiscoveryQueryBatchSize)
         this.config.neighborList.addContacts(closest)
+        const sessions = [this.createSession(targetId)]
+        if (doAdditionalRandomPeerDiscovery) {
+            sessions.push(this.createSession(createRandomKademliaId()))
+        }
+        await this.runSessions(sessions, entryPointDescriptor, retry)
+        this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+
+    }
+
+    private createSession(targetId: Uint8Array): DiscoverySession {
         const sessionOptions = {
             bucket: this.config.bucket,
             neighborList: this.config.neighborList,
-            targetId: this.config.ownPeerId.value,
+            targetId,
             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)
+            newContactListener: (newPeer: RemoteDhtNode) => this.config.addContact(newPeer.getPeerDescriptor())
         }
+        return new DiscoverySession(sessionOptions)
+    }
+
+    private async runSessions(sessions: DiscoverySession[], entryPointDescriptor: PeerDescriptor, retry: boolean): Promise<void> {
         try {
-            await session.findClosestNodes(this.config.joinTimeout)
-            if (randomSession) {
-                await randomSession.findClosestNodes(this.config.joinTimeout)
+            for (const session of sessions) {
+                this.ongoingDiscoverySessions.set(session.sessionId, session)
+                await session.findClosestNodes(this.config.joinTimeout)
             }
         } catch (_e) {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
-            if (!this.stopped) {
+            if (!this.isStopped()) {
                 if (this.config.bucket.count() === 0) {
                     if (retry) {
                         setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
@@ -102,19 +104,15 @@ export class PeerDiscovery {
                     await this.ensureRecoveryIntervalIsRunning()
                 }
             }
-            this.ongoingDiscoverySessions.delete(session.sessionId)
-            if (randomSession) {
-                this.ongoingDiscoverySessions.delete(randomSession.sessionId)
-            }
-            this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.sessionId))
         }
     }
 
     public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
-        if (this.stopped || this.rejoinOngoing) {
+        if (this.isStopped() || this.rejoinOngoing) {
             return
         }
-        logger.debug(`Rejoining DHT ${this.config.serviceId} ${this.config.ownPeerDescriptor.nodeName}!`)
+        logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
             this.config.neighborList.clear()
@@ -122,7 +120,7 @@ export class PeerDiscovery {
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
-            if (!this.stopped) {
+            if (!this.isStopped()) {
                 setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.abortController.signal)
             }
         } finally {
@@ -138,10 +136,11 @@ export class PeerDiscovery {
     }
 
     private async fetchClosestPeersFromBucket(): Promise<void> {
-        if (this.stopped) {
+        if (this.isStopped()) {
             return
         }
-        await Promise.allSettled(this.config.bucket.closest(this.config.ownPeerId.value, this.config.parallelism).map(async (peer: DhtPeer) => {
+        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)
             contacts.forEach((contact) => {
                 this.config.addContact(contact)
@@ -157,8 +156,11 @@ export class PeerDiscovery {
         return this.joinCalled
     }
 
+    private isStopped() {
+        return this.abortController.signal.aborted
+    }
+
     public stop(): void {
-        this.stopped = true
         this.abortController.abort()
         if (this.rejoinTimeoutRef) {
             clearTimeout(this.rejoinTimeoutRef)

package/src/dht/find/RecursiveFindSession.ts

@@ -1,8 +1,7 @@
-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 { DataEntry, PeerDescriptor, FindResponse } 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'
@@ -20,21 +19,21 @@ const logger = new Logger(module)
 
 export interface RecursiveFindSessionConfig {
     serviceId: string
-    rpcTransport: ITransport
+    transport: ITransport
     kademliaIdToFind: Uint8Array
-    ownPeerID: PeerID
+    ownPeerId: PeerID
     waitedRoutingPathCompletions: number
-    mode: FindMode
+    fetchData: boolean
 }
 
 export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvents> implements IRecursiveFindSessionService {
     private readonly serviceId: string
-    private readonly rpcTransport: ITransport
+    private readonly transport: ITransport
     private readonly kademliaIdToFind: Uint8Array
-    private readonly ownPeerID: PeerID
+    private readonly ownPeerId: PeerID
     private readonly waitedRoutingPathCompletions: number
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly mode: FindMode
+    private readonly fetchData: boolean
     private results: SortedContactList<Contact>
     private foundData: Map<string, DataEntry> = new Map()
     private allKnownHops: Set<PeerIDKey> = new Set()
@@ -46,17 +45,17 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
     constructor(config: RecursiveFindSessionConfig) {
         super()
         this.serviceId = config.serviceId
-        this.rpcTransport = config.rpcTransport
+        this.transport = config.transport
         this.kademliaIdToFind = config.kademliaIdToFind
-        this.ownPeerID = config.ownPeerID
+        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, {
+        this.fetchData = config.fetchData
+        this.rpcCommunicator = new ListeningRpcCommunicator(this.serviceId, this.transport, {
             rpcRequestTimeout: 15000
         })
-        this.rpcCommunicator.registerRpcNotification(RecursiveFindReport, 'reportRecursiveFindResult',
-            (req: RecursiveFindReport, context) => this.reportRecursiveFindResult(req, context))
+        this.rpcCommunicator.registerRpcNotification(FindResponse, 'sendFindResponse',
+            (req: FindResponse) => this.sendFindResponse(req))
     }
 
     private isFindCompleted(): boolean {
@@ -65,10 +64,10 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
             unreportedHops.delete(id)
         })
         if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
-            if (this.mode === FindMode.DATA 
+            if (this.fetchData
                 && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.waitedRoutingPathCompletions)) {
                 return true
-            } else if (this.mode === FindMode.DATA) {
+            } else if (this.fetchData) {
                 return false
             }
             return true
@@ -80,7 +79,7 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
         return Array.from(this.foundData.values()).some((entry) => entry.stale === false)
     }
 
-    public doReportRecursiveFindResult(
+    public doSendFindResponse(
         routingPath: PeerDescriptor[],
         nodes: PeerDescriptor[],
         dataEntries: DataEntry[],
@@ -90,7 +89,7 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
         if (routingPath.length >= 1) {
             this.setHopAsReported(routingPath[routingPath.length - 1])
         }
-        nodes.map((descriptor: PeerDescriptor) => {
+        nodes.forEach((descriptor: PeerDescriptor) => {
             this.results.addContact(new Contact(descriptor))
         })
         this.processFoundData(dataEntries)
@@ -102,7 +101,7 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
     private addKnownHops(routingPath: PeerDescriptor[]) {
         routingPath.forEach((desc) => {
             const newPeerId = PeerID.fromValue(desc.kademliaId)
-            if (!this.ownPeerID.equals(newPeerId)) {
+            if (!this.ownPeerId.equals(newPeerId)) {
                 this.allKnownHops.add(newPeerId.toKey())
             }
         })
@@ -110,7 +109,7 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
 
     private setHopAsReported(desc: PeerDescriptor) {
         const newPeerId = PeerID.fromValue(desc.kademliaId)
-        if (!this.ownPeerID.equals(newPeerId)) {
+        if (!this.ownPeerId.equals(newPeerId)) {
             this.reportedHops.add(newPeerId.toKey())
         }
         if (this.isFindCompleted()) {
@@ -157,9 +156,9 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
         }
     }
 
-    public async reportRecursiveFindResult(report: RecursiveFindReport, _context: ServerCallContext): Promise<Empty> {
+    public async sendFindResponse(report: FindResponse): Promise<Empty> {
         logger.trace('recursiveFindReport arrived: ' + JSON.stringify(report))
-        this.doReportRecursiveFindResult(report.routingPath, report.nodes, report.dataEntries, report.noCloserNodesFound)
+        this.doSendFindResponse(report.routingPath, report.closestConnectedPeers, report.dataEntries, report.noCloserNodesFound)
         return {}
     }