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

package/src/dht/DhtNode.ts

@@ -15,16 +15,16 @@ import {
     PeerDescriptor,
     PingRequest,
     PingResponse,
-    FindMode,
     DataEntry,
 } from '../proto/packages/dht/protos/DhtRpc'
 import { DisconnectionType, ITransport, TransportEvents } from '../transport/ITransport'
 import { ConnectionManager, PortRange, TlsCertificate } from '../connection/ConnectionManager'
-import { DhtRpcServiceClient, ExternalApiServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
+import { DhtRpcServiceClient, ExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     Logger,
     MetricsContext,
     hexToBinary,
+    merge,
     waitForCondition
 } from '@streamr/utils'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
@@ -35,12 +35,12 @@ import { Any } from '../proto/google/protobuf/any'
 import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Router } from './routing/Router'
 import { RecursiveFinder, RecursiveFindResult } from './find/RecursiveFinder'
-import { DataStore } from './store/DataStore'
+import { StoreRpcLocal } from './store/StoreRpcLocal'
 import { PeerDiscovery } from './discovery/PeerDiscovery'
 import { LocalDataStore } from './store/LocalDataStore'
-import { IceServer } from '../connection/WebRTC/WebRtcConnector'
+import { IceServer } from '../connection/WebRTC/WebRtcConnectorRpcLocal'
 import { registerExternalApiRpcMethods } from './registerExternalApiRpcMethods'
-import { RemoteExternalApi } from './RemoteExternalApi'
+import { ExternalApiRpcRemote } from './ExternalApiRpcRemote'
 import { UUID } from '../helpers/UUID'
 import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
 import { sample } from 'lodash'
@@ -65,13 +65,13 @@ export interface DhtNodeOptions {
     maxNeighborListSize?: number
     numberOfNodesPerKBucket?: number
     joinNoProgressLimit?: number
-    getClosestContactsLimit?: number  // TODO better name?
+    peerDiscoveryQueryBatchSize?: number
     dhtJoinTimeout?: number
     metricsContext?: MetricsContext
     storeHighestTtl?: number
     storeMaxTtl?: number
     networkConnectivityTimeout?: number
-    storeNumberOfCopies?: number  // TODO better name?
+    storageRedundancyFactor?: number
 
     transport?: ITransport
     peerDescriptor?: PeerDescriptor
@@ -100,12 +100,12 @@ type StrictDhtNodeOptions = MarkRequired<DhtNodeOptions,
     'numberOfNodesPerKBucket' |
     'joinNoProgressLimit' |
     'dhtJoinTimeout' |
-    'getClosestContactsLimit' |
+    'peerDiscoveryQueryBatchSize' |
     'maxConnections' |
     'storeHighestTtl' |
     'storeMaxTtl' |
     'networkConnectivityTimeout' |
-    'storeNumberOfCopies' |
+    'storageRedundancyFactor' |
     'metricsContext' |
     'peerId'>
 
@@ -141,7 +141,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private transport?: ITransport
     private ownPeerDescriptor?: PeerDescriptor
     public router?: Router
-    public dataStore?: DataStore
+    private storeRpcLocal?: StoreRpcLocal
     private localDataStore = new LocalDataStore()
     private recursiveFinder?: RecursiveFinder
     private peerDiscovery?: PeerDiscovery
@@ -153,23 +153,22 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     constructor(conf: DhtNodeOptions) {
         super()
-        this.config = {
+        this.config = merge({
             serviceId: 'layer0',
             joinParallelism: 3,
             maxNeighborListSize: 200,
             numberOfNodesPerKBucket: 8,
             joinNoProgressLimit: 4,
             dhtJoinTimeout: 60000,
-            getClosestContactsLimit: 5,
+            peerDiscoveryQueryBatchSize: 5,
             maxConnections: 80,
             storeHighestTtl: 60000,
             storeMaxTtl: 60000,
             networkConnectivityTimeout: 10000,
-            storeNumberOfCopies: 5,
+            storageRedundancyFactor: 5,
             metricsContext: new MetricsContext(),
-            peerId: new UUID().toHex(),
-            ...conf  // TODO use merge() if we don't want that explicit undefined values override defaults?
-        }
+            peerId: new UUID().toHex()
+        }, conf)
         this.send = this.send.bind(this)
     }
 
@@ -250,7 +249,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             randomPeers: this.randomPeers!,
             openInternetPeers: this.openInternetPeers!,
             joinNoProgressLimit: this.config.joinNoProgressLimit,
-            getClosestContactsLimit: this.config.getClosestContactsLimit,
+            peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
             joinTimeout: this.config.dhtJoinTimeout,
             serviceId: this.config.serviceId,
             parallelism: this.config.joinParallelism,
@@ -276,14 +275,14 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             isPeerCloserToIdThanSelf: this.isPeerCloserToIdThanSelf.bind(this),
             localDataStore: this.localDataStore
         })
-        this.dataStore = new DataStore({
+        this.storeRpcLocal = new StoreRpcLocal({
             rpcCommunicator: this.rpcCommunicator,
             recursiveFinder: this.recursiveFinder,
             ownPeerDescriptor: this.ownPeerDescriptor!,
             serviceId: this.config.serviceId,
             highestTtl: this.config.storeHighestTtl,
             maxTtl: this.config.storeMaxTtl,
-            numberOfCopies: this.config.storeNumberOfCopies,
+            redundancyFactor: this.config.storageRedundancyFactor,
             localDataStore: this.localDataStore,
             dhtNodeEmitter: this,
             getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => {
@@ -492,7 +491,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 this.emit(
                     'newKbucketContact',
                     contact.getPeerDescriptor(),
-                    this.neighborList!.getClosestContacts(this.config.getClosestContactsLimit).map((peer) => peer.getPeerDescriptor())
+                    this.neighborList!.getClosestContacts(this.config.peerDiscoveryQueryBatchSize).map((peer) => peer.getPeerDescriptor())
                 )
             } else {    // open connection by pinging
                 logger.trace('starting ping ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
@@ -502,7 +501,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                         this.emit(
                             'newKbucketContact',
                             contact.getPeerDescriptor(),
-                            this.neighborList!.getClosestContacts(this.config.getClosestContactsLimit).map((peer) => peer.getPeerDescriptor())
+                            this.neighborList!.getClosestContacts(this.config.peerDiscoveryQueryBatchSize).map((peer) => peer.getPeerDescriptor())
                         )
                     } else {
                         logger.trace('ping failed ' + keyFromPeerDescriptor(contact.getPeerDescriptor()))
@@ -618,49 +617,49 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         ))
     }
 
-    public async startRecursiveFind(idToFind: Uint8Array, findMode?: FindMode, excludedPeer?: PeerDescriptor): Promise<RecursiveFindResult> {
-        return this.recursiveFinder!.startRecursiveFind(idToFind, findMode, excludedPeer)
+    public async startRecursiveFind(idToFind: Uint8Array, fetchData?: boolean, excludedPeer?: PeerDescriptor): Promise<RecursiveFindResult> {
+        return this.recursiveFinder!.startRecursiveFind(idToFind, fetchData, excludedPeer)
     }
 
     public async storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]> {
         if (this.peerDiscovery!.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
             return this.storeDataViaPeer(key, data, sample(this.config.entryPoints)!)
         }
-        return this.dataStore!.storeDataToDht(key, data)
+        return this.storeRpcLocal!.storeDataToDht(key, data)
     }
 
     public async storeDataViaPeer(key: Uint8Array, data: Any, peer: PeerDescriptor): Promise<PeerDescriptor[]> {
-        const target = new RemoteExternalApi(
+        const rpcRemote = new ExternalApiRpcRemote(
             this.ownPeerDescriptor!,
             peer,
             this.config.serviceId,
-            toProtoRpcClient(new ExternalApiServiceClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ExternalApiRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
-        return await target.storeData(key, data)
+        return await rpcRemote.storeData(key, data)
     }
 
     public async getDataFromDht(idToFind: Uint8Array): Promise<DataEntry[]> {
         if (this.peerDiscovery!.isJoinOngoing() && this.config.entryPoints && this.config.entryPoints.length > 0) {
             return this.findDataViaPeer(idToFind, sample(this.config.entryPoints)!)
         }
-        const result = await this.recursiveFinder!.startRecursiveFind(idToFind, FindMode.DATA)
+        const result = await this.recursiveFinder!.startRecursiveFind(idToFind, true)
         return result.dataEntries ?? []
     }
 
     public async deleteDataFromDht(idToDelete: Uint8Array): Promise<void> {
         if (!this.stopped) {
-            return this.dataStore!.deleteDataFromDht(idToDelete)
+            return this.storeRpcLocal!.deleteDataFromDht(idToDelete)
         }
     }
 
     public async findDataViaPeer(idToFind: Uint8Array, peer: PeerDescriptor): Promise<DataEntry[]> {
-        const target = new RemoteExternalApi(
+        const rpcRemote = new ExternalApiRpcRemote(
             this.ownPeerDescriptor!,
             peer,
             this.config.serviceId,
-            toProtoRpcClient(new ExternalApiServiceClient(this.rpcCommunicator!.getRpcClientTransport()))
+            toProtoRpcClient(new ExternalApiRpcClient(this.rpcCommunicator!.getRpcClientTransport()))
         )
-        return await target.findData(idToFind)
+        return await rpcRemote.findData(idToFind)
     }
 
     public getRpcCommunicator(): RoutingRpcCommunicator {
@@ -740,7 +739,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
         this.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
         const response = {
-            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.getClosestContactsLimit),
+            peers: this.getClosestPeerDescriptors(request.kademliaId, this.config.peerDiscoveryQueryBatchSize),
             requestId: request.requestId
         }
         return response

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/discovery/PeerDiscovery.ts

@@ -20,7 +20,7 @@ interface PeerDiscoveryConfig {
     randomPeers: RandomContactList<RemoteDhtNode>
     openInternetPeers: SortedContactList<RemoteDhtNode>
     joinNoProgressLimit: number
-    getClosestContactsLimit: number
+    peerDiscoveryQueryBatchSize: number
     serviceId: string
     parallelism: number
     joinTimeout: number
@@ -59,9 +59,10 @@ export class PeerDiscovery {
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
         this.config.addContact(entryPointDescriptor)
-        const closest = this.config.bucket.closest(peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).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(peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value)]
+        const sessions = [this.createSession(targetId)]
         if (doAdditionalRandomPeerDiscovery) {
             sessions.push(this.createSession(createRandomKademliaId()))
         }

package/src/dht/find/RecursiveFindSession.ts

@@ -1,7 +1,7 @@
 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'
@@ -23,7 +23,7 @@ export interface RecursiveFindSessionConfig {
     kademliaIdToFind: Uint8Array
     ownPeerId: PeerID
     waitedRoutingPathCompletions: number
-    mode: FindMode
+    fetchData: boolean
 }
 
 export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvents> implements IRecursiveFindSessionService {
@@ -33,7 +33,7 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
     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()
@@ -50,12 +50,12 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
         this.ownPeerId = config.ownPeerId
         this.waitedRoutingPathCompletions = config.waitedRoutingPathCompletions
         this.results = new SortedContactList(PeerID.fromValue(this.kademliaIdToFind), 10, undefined, true)
-        this.mode = config.mode
+        this.fetchData = config.fetchData
         this.rpcCommunicator = new ListeningRpcCommunicator(this.serviceId, this.transport, {
             rpcRequestTimeout: 15000
         })
-        this.rpcCommunicator.registerRpcNotification(RecursiveFindReport, 'reportRecursiveFindResult',
-            (req: RecursiveFindReport) => this.reportRecursiveFindResult(req))
+        this.rpcCommunicator.registerRpcNotification(FindResponse, 'sendFindResponse',
+            (req: FindResponse) => this.sendFindResponse(req))
     }
 
     private isFindCompleted(): boolean {
@@ -64,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
@@ -79,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[],
@@ -156,9 +156,9 @@ export class RecursiveFindSession extends EventEmitter<RecursiveFindSessionEvent
         }
     }
 
-    public async reportRecursiveFindResult(report: RecursiveFindReport): 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 {}
     }
 

package/src/dht/find/RecursiveFinder.ts

@@ -1,11 +1,10 @@
 import {
     DataEntry,
-    FindMode,
     Message,
     MessageType,
     NodeType,
     PeerDescriptor,
-    RecursiveFindRequest,
+    FindRequest,
     RouteMessageAck,
     RouteMessageWrapper
 } from '../../proto/packages/dht/protos/DhtRpc'
@@ -21,7 +20,7 @@ import { RecursiveFindSession, RecursiveFindSessionEvents } from './RecursiveFin
 import { RemoteDhtNode } from '../RemoteDhtNode'
 import { ITransport } from '../../transport/ITransport'
 import { LocalDataStore } from '../store/LocalDataStore'
-import { IRoutingService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { IRouterRpc } 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'
@@ -40,10 +39,10 @@ interface RecursiveFinderConfig {
 }
 
 interface RecursiveFinderFunc {
-    startRecursiveFind(idToFind: Uint8Array, findMode?: FindMode): Promise<RecursiveFindResult>
+    startRecursiveFind(idToFind: Uint8Array, fetchData?: boolean): Promise<RecursiveFindResult>
 }
 
-export interface IRecursiveFinder extends Pick<IRoutingService, 'findRecursively'>, RecursiveFinderFunc {}
+export interface IRecursiveFinder extends Pick<IRouterRpc, 'findRecursively'>, RecursiveFinderFunc {}
 
 export interface RecursiveFindResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
 
@@ -79,7 +78,7 @@ export class RecursiveFinder implements IRecursiveFinder {
 
     public async startRecursiveFind(
         idToFind: Uint8Array,
-        findMode: FindMode = FindMode.NODE,
+        fetchData: boolean = false,
         excludedPeer?: PeerDescriptor
     ): Promise<RecursiveFindResult> {
         if (this.stopped) {
@@ -92,11 +91,11 @@ export class RecursiveFinder implements IRecursiveFinder {
             kademliaIdToFind: idToFind,
             ownPeerId: peerIdFromPeerDescriptor(this.ownPeerDescriptor),
             waitedRoutingPathCompletions: this.connections.size > 1 ? 2 : 1,
-            mode: findMode
+            fetchData
         })
         if (this.connections.size === 0) {
             const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
-            recursiveFindSession.doReportRecursiveFindResult(
+            recursiveFindSession.doSendFindResponse(
                 [this.ownPeerDescriptor],
                 [this.ownPeerDescriptor],
                 data ? Array.from(data.values()) : [],
@@ -104,7 +103,7 @@ export class RecursiveFinder implements IRecursiveFinder {
             )
             return recursiveFindSession.getResults()
         }
-        const routeMessage = this.wrapRecursiveFindRequest(idToFind, sessionId, findMode)
+        const routeMessage = this.wrapFindRequest(idToFind, sessionId, fetchData)
         this.ongoingSessions.set(sessionId, recursiveFindSession)
         try {
             await runAndWaitForEvents3<RecursiveFindSessionEvents>(
@@ -115,28 +114,28 @@ export class RecursiveFinder implements IRecursiveFinder {
         } catch (err) {
             logger.debug(`doFindRecursively failed with error ${err}`)
         }
-        this.findAndReportLocalData(idToFind, findMode, [], this.ownPeerDescriptor, sessionId)
+        this.findAndReportLocalData(idToFind, fetchData, [], this.ownPeerDescriptor, sessionId)
         this.ongoingSessions.delete(sessionId)
         recursiveFindSession.stop()
         return recursiveFindSession.getResults()
     }
 
-    private wrapRecursiveFindRequest(idToFind: Uint8Array, sessionId: string, findMode: FindMode): RouteMessageWrapper {
+    private wrapFindRequest(idToFind: Uint8Array, sessionId: string, fetchData: boolean): RouteMessageWrapper {
         const targetDescriptor: PeerDescriptor = {
             kademliaId: idToFind,
             type: NodeType.VIRTUAL
         }
-        const request: RecursiveFindRequest = {
-            recursiveFindSessionId: sessionId,
-            findMode
+        const request: FindRequest = {
+            sessionId,
+            fetchData
         }
         const msg: Message = {
             messageType: MessageType.RECURSIVE_FIND_REQUEST,
             messageId: v4(),
             serviceId: this.serviceId,
             body: {
-                oneofKind: 'recursiveFindRequest',
-                recursiveFindRequest: request
+                oneofKind: 'findRequest',
+                findRequest: request
             }
         }
         const routeMessage: RouteMessageWrapper = {
@@ -152,29 +151,29 @@ export class RecursiveFinder implements IRecursiveFinder {
 
     private findAndReportLocalData(
         idToFind: Uint8Array,
-        findMode: FindMode,
+        fetchData: boolean,
         routingPath: PeerDescriptor[],
         sourcePeer: PeerDescriptor,
         sessionId: string
     ): boolean {
-        if (findMode === FindMode.DATA) {
+        if (fetchData) {
             const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
             if (data.size > 0) {
-                this.reportRecursiveFindResult(routingPath, sourcePeer, sessionId, [], data, true)
+                this.sendFindResponse(routingPath, sourcePeer, sessionId, [], data, true)
                 return true
             }
         }
         return false
     }
 
-    private findLocalData(idToFind: Uint8Array, findMode: FindMode): Map<PeerIDKey, DataEntry> | undefined {
-        if (findMode === FindMode.DATA) {
+    private findLocalData(idToFind: Uint8Array, fetchData: boolean): Map<PeerIDKey, DataEntry> | undefined {
+        if (fetchData) {
             return this.localDataStore.getEntry(PeerID.fromValue(idToFind))
         }
         return undefined
     }
 
-    private reportRecursiveFindResult(
+    private sendFindResponse(
         routingPath: PeerDescriptor[],
         targetPeerDescriptor: PeerDescriptor,
         serviceId: string,
@@ -186,7 +185,7 @@ export class RecursiveFinder implements IRecursiveFinder {
         const isOwnNode = areEqualPeerDescriptors(this.ownPeerDescriptor, targetPeerDescriptor)
         if (isOwnNode && this.ongoingSessions.has(serviceId)) {
             this.ongoingSessions.get(serviceId)!
-                .doReportRecursiveFindResult(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+                .doSendFindResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
         } else {
             const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.sessionTransport, { rpcRequestTimeout: 15000 })
             const remoteSession = new RemoteRecursiveFindSession(
@@ -195,7 +194,7 @@ export class RecursiveFinder implements IRecursiveFinder {
                 serviceId,
                 toProtoRpcClient(new RecursiveFindSessionServiceClient(remoteCommunicator.getRpcClientTransport()))
             )
-            remoteSession.reportRecursiveFindResult(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+            remoteSession.sendFindResponse(routingPath, closestNodes, dataEntries, noCloserNodesFound)
         }
     }
 
@@ -205,18 +204,18 @@ export class RecursiveFinder implements IRecursiveFinder {
         }
         const idToFind = peerIdFromPeerDescriptor(routedMessage.destinationPeer!)
         const msg = routedMessage.message
-        const recursiveFindRequest = msg?.body.oneofKind === 'recursiveFindRequest' ? msg.body.recursiveFindRequest : undefined
+        const findRequest = msg?.body.oneofKind === 'findRequest' ? msg.body.findRequest : undefined
         const closestPeersToDestination = this.getClosestConnections(routedMessage.destinationPeer!.kademliaId, 5)
-        const data = this.findLocalData(idToFind.value, recursiveFindRequest!.findMode)
+        const data = this.findLocalData(idToFind.value, findRequest!.fetchData)
         if (areEqualPeerDescriptors(this.ownPeerDescriptor, routedMessage.destinationPeer!)) {
-            this.reportRecursiveFindResult(routedMessage.routingPath, routedMessage.sourcePeer!, recursiveFindRequest!.recursiveFindSessionId,
+            this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
                 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 found no candidates`)
-            this.reportRecursiveFindResult(routedMessage.routingPath, routedMessage.sourcePeer!, recursiveFindRequest!.recursiveFindSessionId,
+            this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
                 closestPeersToDestination, data, true)
         } else if (ack.error) {
             return ack
@@ -226,7 +225,7 @@ export class RecursiveFinder implements IRecursiveFinder {
                 && routedMessage.previousPeer
                 && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], idToFind)
             )
-            this.reportRecursiveFindResult(routedMessage.routingPath, routedMessage.sourcePeer!, recursiveFindRequest!.recursiveFindSessionId,
+            this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
                 closestPeersToDestination, data, noCloserContactsFound)
         }
         return ack
@@ -245,7 +244,7 @@ export class RecursiveFinder implements IRecursiveFinder {
         return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
     }
 
-    // IRoutingService method
+    // IRouterRpc method
     async findRecursively(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, 'findRecursively() service is not running')

package/src/dht/find/RemoteRecursiveFindSession.ts

@@ -1,7 +1,7 @@
 import {
     DataEntry,
     PeerDescriptor,
-    RecursiveFindReport
+    FindResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { IRecursiveFindSessionServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
@@ -11,16 +11,16 @@ const logger = new Logger(module)
 
 export class RemoteRecursiveFindSession extends Remote<IRecursiveFindSessionServiceClient> {
 
-    reportRecursiveFindResult(routingPath: PeerDescriptor[], closestNodes: PeerDescriptor[], 
+    sendFindResponse(routingPath: PeerDescriptor[], closestNodes: PeerDescriptor[], 
         dataEntries: DataEntry[], noCloserNodesFound: boolean): void {
-        const report: RecursiveFindReport = {
+        const report: FindResponse = {
             routingPath,
-            nodes: closestNodes,
+            closestConnectedPeers: closestNodes,
             dataEntries,
             noCloserNodesFound
         }
-        this.getClient().reportRecursiveFindResult(report, this.formDhtRpcOptions()).catch((_e) => {
-            logger.trace('Failed to send RecursiveFindResult')
+        this.getClient().sendFindResponse(report, this.formDhtRpcOptions()).catch((_e) => {
+            logger.trace('Failed to send FindResult')
         })
     }
 }

package/src/dht/registerExternalApiRpcMethods.ts

@@ -1,5 +1,7 @@
 import { DhtNode } from '../dht/DhtNode'
-import { ExternalStoreDataRequest, ExternalStoreDataResponse, FindDataRequest, FindDataResponse, FindMode } from '../proto/packages/dht/protos/DhtRpc'
+import { ExternalStoreDataRequest, ExternalStoreDataResponse, FindDataRequest, FindDataResponse } from '../proto/packages/dht/protos/DhtRpc'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 
 export const registerExternalApiRpcMethods = (thisNode: DhtNode): void => {
     const rpcCommunicator = thisNode.getRpcCommunicator()
@@ -7,7 +9,7 @@ export const registerExternalApiRpcMethods = (thisNode: DhtNode): void => {
         FindDataRequest, 
         FindDataResponse, 
         'findData', 
-        (req: FindDataRequest) => findData(thisNode, req),
+        (req: FindDataRequest, context: ServerCallContext) => findData(thisNode, req, context),
         { timeout: 10000 }
     )
     rpcCommunicator.registerRpcMethod(
@@ -20,8 +22,9 @@ export const registerExternalApiRpcMethods = (thisNode: DhtNode): void => {
 }
 
 // IDHTRpcService method for external findRecursive calls
-const findData = async (thisNode: DhtNode, findDataRequest: FindDataRequest): Promise<FindDataResponse> => {
-    const result = await thisNode.startRecursiveFind(findDataRequest.kademliaId, FindMode.DATA, findDataRequest.requestor)
+const findData = async (thisNode: DhtNode, findDataRequest: FindDataRequest, context: ServerCallContext): Promise<FindDataResponse> => {
+    const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+    const result = await thisNode.startRecursiveFind(findDataRequest.kademliaId, true, senderPeerDescriptor)
     if (result.dataEntries) {
         return FindDataResponse.create({ dataEntries: result.dataEntries })
     } else {

package/src/dht/routing/Router.ts

@@ -8,13 +8,11 @@ import { DuplicateDetector } from './DuplicateDetector'
 import { ConnectionManager } from '../../connection/ConnectionManager'
 import { RemoteDhtNode } from '../RemoteDhtNode'
 import { v4 } from 'uuid'
-import { IRoutingService } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 
 export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?: string): RouteMessageAck => {
     const ack: RouteMessageAck = {
         requestId: routedMessage.requestId,
-        destinationPeer: routedMessage.sourcePeer,
-        sourcePeer: routedMessage.destinationPeer,
         error: error ? error : ''
     }
     return ack
@@ -49,7 +47,7 @@ interface IRouterFunc {
     stop(): void
 }
 
-export interface IRouter extends Omit<IRoutingService, 'findRecursively'>, IRouterFunc {}
+export interface IRouter extends Omit<IRouterRpc, 'findRecursively'>, IRouterFunc {}
 
 const logger = new Logger(module)
 
@@ -194,7 +192,7 @@ export class Router implements IRouter {
         this.duplicateRequestDetector.clear()
     }
     
-    // IRoutingService method
+    // IRouterRpc method
     async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, 'routeMessage() service is not running')
@@ -238,7 +236,7 @@ export class Router implements IRouter {
         }
     }
 
-    // IRoutingService method
+    // IRouterRpc method
     async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.stopped) {
             return createRouteMessageAck(forwardMessage, 'forwardMessage() service is not running')

package/src/dht/routing/{RemoteRouter.ts → RouterRpcRemote.ts}

@@ -5,13 +5,13 @@ import {
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
-import { IRoutingServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IRouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Remote } from '../contact/Remote'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
 
-export class RemoteRouter extends Remote<IRoutingServiceClient> {
+export class RouterRpcRemote extends Remote<IRouterRpcClient> {
 
     async routeMessage(params: RouteMessageWrapper): Promise<boolean> {
         const message: RouteMessageWrapper = {