@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

package/src/dht/contact/SortedContactList.ts

@@ -1,26 +1,34 @@
-import KBucket from 'k-bucket'
-import { PeerID } from '../../helpers/PeerID'
-import { ContactList, ContactState } from './ContactList'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { ContactState, Events } from './ContactList'
+import { sortedIndexBy } from 'lodash'
+import EventEmitter from 'eventemitter3'
+import { getDistance } from '../PeerManager'
+
+export interface SortedContactListConfig {
+    referenceId: PeerID  // all contacts in this list are in sorted by the distance to this ID
+    allowToContainReferenceId: boolean
+    // TODO could maybe optimize this by removing the flag and then we'd check whether we have 
+    // any listeners before we emit the event
+    emitEvents: boolean
+    maxSize?: number
+    // if set, the list can't contain any contacts which are futher away than this limit
+    peerIdDistanceLimit?: PeerID
+    // if set, the list can't contain contacts with these ids
+    excludedPeerIDs?: PeerID[]
+}
 
-export class SortedContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
+export class SortedContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
 
-    private allowLocalPeerId: boolean
-    private peerIdDistanceLimit?: PeerID
-    private excludedPeerIDs?: PeerID[]
+    private config: SortedContactListConfig
+    private contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
+    private contactIds: PeerID[] = []
 
     constructor(
-        ownId: PeerID,
-        maxSize: number,
-        defaultContactQueryLimit?: number,
-        allowLocalPeerId = false,
-        peerIdDistanceLimit?: PeerID,
-        excludedPeerIDs?: PeerID[]
+        config: SortedContactListConfig
     ) {
-        super(ownId, maxSize, defaultContactQueryLimit)
+        super()
+        this.config = config
         this.compareIds = this.compareIds.bind(this)
-        this.allowLocalPeerId = allowLocalPeerId
-        this.peerIdDistanceLimit = peerIdDistanceLimit
-        this.excludedPeerIDs = excludedPeerIDs
     }
 
     public getClosestContactId(): PeerID {
@@ -32,38 +40,44 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     }
 
     public addContact(contact: C): void {
-        if (this.excludedPeerIDs
-            && this.excludedPeerIDs.some((peerId) => contact.getPeerId().equals(peerId))) {
+        if (this.config.excludedPeerIDs !== undefined
+            && this.config.excludedPeerIDs.some((peerId) => contact.getPeerId().equals(peerId))) {
             return
         }
-        
-        if ((!this.allowLocalPeerId && this.ownId.equals(contact.getPeerId())) ||
-            (this.peerIdDistanceLimit !== undefined && this.compareIds(this.peerIdDistanceLimit, contact.getPeerId()) < 0)) {
+
+        if ((!this.config.allowToContainReferenceId && this.config.referenceId.equals(contact.getPeerId())) ||
+            (this.config.peerIdDistanceLimit !== undefined && this.compareIds(this.config.peerIdDistanceLimit, contact.getPeerId()) < 0)) {
             return
         }
         if (!this.contactsById.has(contact.getPeerId().toKey())) {
-            if (this.contactIds.length < this.maxSize) {
+            if ((this.config.maxSize === undefined) || (this.contactIds.length < this.config.maxSize)) {
                 this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
-                this.contactIds.push(contact.getPeerId())
-                this.contactIds.sort(this.compareIds)
-            } else if (this.compareIds(this.contactIds[this.maxSize - 1], contact.getPeerId()) > 0) {
+
+                const index = sortedIndexBy(this.contactIds, contact.getPeerId(), (id: PeerID) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contact.getPeerId())
+            } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contact.getPeerId()) > 0) {
                 const removedId = this.contactIds.pop()
                 const removedContact = this.contactsById.get(removedId!.toKey())!.contact
                 this.contactsById.delete(removedId!.toKey())
                 this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
-                this.contactIds.push(contact.getPeerId())
-                this.contactIds.sort(this.compareIds)
+
+                const index = sortedIndexBy(this.contactIds, contact.getPeerId(), (id: PeerID) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contact.getPeerId())
+                if (this.config.emitEvents) {
+                    this.emit(
+                        'contactRemoved',
+                        removedContact,
+                        this.getClosestContacts()
+                    )
+                }
+            }
+            if (this.config.emitEvents) {
                 this.emit(
-                    'contactRemoved',
-                    removedContact,
+                    'newContact',
+                    contact,
                     this.getClosestContacts()
                 )
             }
-            this.emit(
-                'newContact',
-                contact,
-                this.getClosestContacts()
-            )
         }
     }
 
@@ -71,6 +85,10 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         contacts.forEach((contact) => this.addContact(contact))
     }
 
+    public getContact(id: PeerID): ContactState<C> | undefined {
+        return this.contactsById.get(id.toKey())
+    }
+
     public setContacted(contactId: PeerID): void {
         if (this.contactsById.has(contactId.toKey())) {
             this.contactsById.get(contactId.toKey())!.contacted = true
@@ -83,7 +101,7 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         }
     }
 
-    public getClosestContacts(limit = this.defaultContactQueryLimit): C[] {
+    public getClosestContacts(limit?: number): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
             const contact = this.contactsById.get(contactId.toKey())
@@ -91,7 +109,11 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
                 ret.push(contact.contact)
             }
         })
-        return ret.slice(0, limit)
+        if (limit === undefined) {
+            return ret
+        } else {
+            return ret.slice(0, limit)
+        }
     }
 
     public getUncontactedContacts(num: number): C[] {
@@ -124,22 +146,29 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     }
 
     public compareIds(id1: PeerID, id2: PeerID): number {
-        const distance1 = KBucket.distance(this.ownId.value, id1.value)
-        const distance2 = KBucket.distance(this.ownId.value, id2.value)
+        const distance1 = this.distanceToReferenceId(id1)
+        const distance2 = this.distanceToReferenceId(id2)
         return distance1 - distance2
     }
 
+    // TODO inline this method?
+    private distanceToReferenceId(id: PeerID): number {
+        return getDistance(this.config.referenceId.value, id.value)
+    }
+
     public removeContact(id: PeerID): boolean {
         if (this.contactsById.has(id.toKey())) {
             const removed = this.contactsById.get(id.toKey())!.contact
             const index = this.contactIds.findIndex((element) => element.equals(id))
             this.contactIds.splice(index, 1)
             this.contactsById.delete(id.toKey())
-            this.emit(
-                'contactRemoved',
-                removed,
-                this.getClosestContacts()
-            )
+            if (this.config.emitEvents) {
+                this.emit(
+                    'contactRemoved',
+                    removed,
+                    this.getClosestContacts()
+                )
+            }
             return true
         }
         return false
@@ -152,4 +181,18 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     public getAllContacts(): C[] {
         return this.contactIds.map((peerId) => this.contactsById.get(peerId.toKey())!.contact)
     }
+
+    public getSize(): number {
+        return this.contactIds.length
+    }
+
+    public clear(): void {
+        this.contactsById.clear()
+        this.contactIds = []
+    }
+
+    public stop(): void {
+        this.removeAllListeners()
+        this.clear()
+    }
 }

package/src/dht/discovery/DiscoverySession.ts

@@ -1,15 +1,11 @@
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
-import KBucket from 'k-bucket'
 import { v4 } from 'uuid'
-import { PeerID } from '../../helpers/PeerID'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { DhtNodeRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { SortedContactList } from '../contact/SortedContactList'
+import { PeerManager, getDistance } from '../PeerManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { ServiceID } from '../../types/ServiceID'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -18,16 +14,10 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    bucket: KBucket<DhtNodeRpcRemote>
-    neighborList: SortedContactList<DhtNodeRpcRemote>
     targetId: Uint8Array
-    localPeerDescriptor: PeerDescriptor
-    serviceId: ServiceID
-    rpcCommunicator: RpcCommunicator
     parallelism: number
     noProgressLimit: number
-    newContactListener?: (rpcRemote: DhtNodeRpcRemote) => void
-    rpcRequestTimeout?: number
+    peerManager: PeerManager
 }
 
 export class DiscoverySession {
@@ -39,6 +29,7 @@ export class DiscoverySession {
     private noProgressCounter = 0
     private ongoingClosestPeersRequests: Set<string> = new Set()
     private readonly config: DiscoverySessionConfig
+    private contactedPeers: Set<PeerIDKey> = new Set()
 
     constructor(config: DiscoverySessionConfig) {
         this.config = config
@@ -48,23 +39,7 @@ export class DiscoverySession {
         if (this.stopped) {
             return
         }
-        contacts.forEach((contact) => {
-            if (!areEqualPeerDescriptors(contact, this.config.localPeerDescriptor)) {
-                const rpcRemote = new DhtNodeRpcRemote(
-                    this.config.localPeerDescriptor,
-                    contact,
-                    toProtoRpcClient(new DhtNodeRpcClient(this.config.rpcCommunicator.getRpcClientTransport())),
-                    this.config.serviceId,
-                    this.config.rpcRequestTimeout
-                )
-                if (this.config.newContactListener) {
-                    this.config.newContactListener(rpcRemote)
-                }
-                if (!this.config.neighborList.getContact(rpcRemote.getPeerId())) {
-                    this.config.neighborList.addContact(rpcRemote)
-                }
-            }
-        })
+        this.config.peerManager.handleNewPeers(contacts)
     }
 
     private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
@@ -73,9 +48,9 @@ export class DiscoverySession {
         }
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
-        this.config.neighborList.setContacted(contact.getPeerId())
+        this.contactedPeers.add(contact.getPeerId().toKey())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
-        this.config.neighborList.setActive(contact.getPeerId())
+        this.config.peerManager.handlePeerActive(contact.getPeerId())
         return returnedContacts
     }
 
@@ -84,9 +59,12 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peerId.toKey())
-        const oldClosestContact = this.config.neighborList.getClosestContactId()
+        const oldClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const oldClosestDistance = getDistance(this.config.targetId, oldClosestNeighbor.getPeerId().value)
         this.addNewContacts(contacts)
-        if (this.config.neighborList.getClosestContactId().equals(oldClosestContact)) {
+        const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const newClosestDistance = getDistance(this.config.targetId, newClosestNeighbor.getPeerId().value)
+        if (newClosestDistance >= oldClosestDistance) {
             this.noProgressCounter++
         } else {
             this.noProgressCounter = 0
@@ -98,15 +76,14 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peer.getPeerId().toKey())
-        this.config.bucket.remove(peer.getPeerId().value)
-        this.config.neighborList.removeContact(peer.getPeerId())
+        this.config.peerManager.handlePeerUnresponsive(peer.getPeerId())
     }
 
     private findMoreContacts(): void {
         if (this.stopped) {
             return
         }
-        const uncontacted = this.config.neighborList.getUncontactedContacts(this.config.parallelism)
+        const uncontacted = this.config.peerManager.getClosestContactsTo(this.config.targetId, this.config.parallelism, this.contactedPeers)
         if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
             this.emitter.emit('discoveryCompleted')
             this.stopped = true
@@ -128,18 +105,16 @@ export class DiscoverySession {
         }
     }
 
-    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
+    public async findClosestNodes(timeout: number): Promise<void> {
+        if (this.config.peerManager.getNumberOfContacts(this.contactedPeers) === 0) {
+            return
         }
+        // TODO add abortController and signal it in stop()
         await runAndWaitForEvents3<DiscoverySessionEvents>(
             [this.findMoreContacts.bind(this)],
             [[this.emitter, 'discoveryCompleted']],
             timeout
         )
-        return this.config.neighborList
     }
 
     public stop(): void {

package/src/dht/discovery/PeerDiscovery.ts

@@ -3,26 +3,20 @@ 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 { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { createRandomKademliaId } from '../../helpers/kademliaId'
+import { PeerManager } from '../PeerManager'
+import { createRandomNodeId } from '../../helpers/nodeId'
 import { ServiceID } from '../../types/ServiceID'
 
 interface PeerDiscoveryConfig {
-    rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
-    bucket: KBucket<DhtNodeRpcRemote>
-    neighborList: SortedContactList<DhtNodeRpcRemote>
     joinNoProgressLimit: number
     peerDiscoveryQueryBatchSize: number
     serviceId: ServiceID
     parallelism: number
     joinTimeout: number
-    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     connectionManager?: ConnectionManager
-    rpcRequestTimeout?: number
+    peerManager: PeerManager
 }
 
 const logger = new Logger(module)
@@ -55,13 +49,11 @@ export class PeerDiscovery {
             return
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
-        this.config.addContact(entryPointDescriptor)
+        this.config.peerManager.handleNewPeers([entryPointDescriptor])
         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)]
         if (doAdditionalRandomPeerDiscovery) {
-            sessions.push(this.createSession(createRandomKademliaId()))
+            sessions.push(this.createSession(createRandomNodeId()))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
         this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
@@ -70,15 +62,10 @@ export class PeerDiscovery {
 
     private createSession(targetId: Uint8Array): DiscoverySession {
         const sessionOptions = {
-            bucket: this.config.bucket,
-            neighborList: this.config.neighborList,
             targetId,
-            localPeerDescriptor: this.config.localPeerDescriptor,
-            serviceId: this.config.serviceId,
-            rpcCommunicator: this.config.rpcCommunicator,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
-            newContactListener: (newPeer: DhtNodeRpcRemote) => this.config.addContact(newPeer.getPeerDescriptor())
+            peerManager: this.config.peerManager
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -93,8 +80,9 @@ export class PeerDiscovery {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
             if (!this.isStopped()) {
-                if (this.config.bucket.count() === 0) {
+                if (this.config.peerManager.getNumberOfNeighbors() === 0) {
                     if (retry) {
+                        // TODO should we catch possible promise rejection?
                         setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
                     }
                 } else {
@@ -112,12 +100,12 @@ export class PeerDiscovery {
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         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.isStopped()) {
+                // TODO should we catch possible promise rejection?
                 setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.abortController.signal)
             }
         } finally {
@@ -136,13 +124,13 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
-        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)
+        const nodes = this.config.peerManager.getClosestNeighborsTo(this.config.localPeerDescriptor.nodeId, this.config.parallelism)
+        await Promise.allSettled(
+            nodes.map(async (peer: DhtNodeRpcRemote) => {
+                const contacts = await peer.getClosestPeers(this.config.localPeerDescriptor.nodeId!)
+                this.config.peerManager.handleNewPeers(contacts)    
             })
-        }))
+        )
     }
 
     public isJoinOngoing(): boolean {
@@ -163,7 +151,7 @@ export class PeerDiscovery {
             clearTimeout(this.rejoinTimeoutRef)
             this.rejoinTimeoutRef = undefined
         }
-        this.ongoingDiscoverySessions.forEach((session, _id) => {
+        this.ongoingDiscoverySessions.forEach((session) => {
             session.stop()
         })
     }

package/src/dht/find/FindRpcLocal.ts

@@ -1,5 +1,5 @@
 import { Logger } from '@streamr/utils'
-import { PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, RouteMessageAck, RouteMessageError, 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'
@@ -24,7 +24,7 @@ export class FindRpcLocal implements IFindRpc {
 
     async routeFindRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.config.isMostLikelyDuplicate(routedMessage.requestId)) {
-            return createRouteMessageAck(routedMessage, 'message given to routeFindRequest() service is likely a duplicate')
+            return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         const senderId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
         logger.trace(`Received routeFindRequest call from ${senderId}`)

package/src/dht/find/FindSession.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'eventemitter3'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { DataEntry, PeerDescriptor, FindResponse } from '../../proto/packages/dht/protos/DhtRpc'
+import { DataEntry, PeerDescriptor, FindResponse, FindAction } from '../../proto/packages/dht/protos/DhtRpc'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { Contact } from '../contact/Contact'
@@ -17,20 +17,20 @@ export interface FindSessionEvents {
 export interface FindSessionConfig {
     serviceId: ServiceID
     transport: ITransport
-    kademliaIdToFind: Uint8Array
+    nodeIdToFind: Uint8Array
     localPeerId: PeerID
     waitedRoutingPathCompletions: number
-    fetchData: boolean
+    action: FindAction
 }
 
 export class FindSession extends EventEmitter<FindSessionEvents> {
     private readonly serviceId: ServiceID
     private readonly transport: ITransport
-    private readonly kademliaIdToFind: Uint8Array
+    private readonly nodeIdToFind: Uint8Array
     private readonly localPeerId: PeerID
     private readonly waitedRoutingPathCompletions: number
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly fetchData: boolean
+    private readonly action: FindAction
     private results: SortedContactList<Contact>
     private foundData: Map<string, DataEntry> = new Map()
     private allKnownHops: Set<PeerIDKey> = new Set()
@@ -43,11 +43,16 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
         super()
         this.serviceId = config.serviceId
         this.transport = config.transport
-        this.kademliaIdToFind = config.kademliaIdToFind
+        this.nodeIdToFind = config.nodeIdToFind
         this.localPeerId = config.localPeerId
         this.waitedRoutingPathCompletions = config.waitedRoutingPathCompletions
-        this.results = new SortedContactList(PeerID.fromValue(this.kademliaIdToFind), 10, undefined, true)
-        this.fetchData = config.fetchData
+        this.results = new SortedContactList({
+            referenceId: PeerID.fromValue(this.nodeIdToFind), 
+            maxSize: 10,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+        this.action = config.action
         this.rpcCommunicator = new ListeningRpcCommunicator(this.serviceId, this.transport, {
             rpcRequestTimeout: 15000
         })
@@ -56,7 +61,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     private registerLocalRpcMethods() {
         const rpcLocal = new FindSessionRpcLocal({
-            doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound?: boolean) => {
+            doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => {
                 this.doSendFindResponse(routingPath, nodes, dataEntries, noCloserNodesFound)
             }
         })
@@ -70,10 +75,10 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
             unreportedHops.delete(id)
         })
         if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
-            if (this.fetchData
+            if (this.action === FindAction.FETCH_DATA
                 && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.waitedRoutingPathCompletions)) {
                 return true
-            } else if (this.fetchData) {
+            } else if (this.action === FindAction.FETCH_DATA) {
                 return false
             }
             return true
@@ -89,7 +94,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
         routingPath: PeerDescriptor[],
         nodes: PeerDescriptor[],
         dataEntries: DataEntry[],
-        noCloserNodesFound?: boolean
+        noCloserNodesFound: boolean
     ): void {
         this.addKnownHops(routingPath)
         if (routingPath.length >= 1) {
@@ -106,7 +111,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     private addKnownHops(routingPath: PeerDescriptor[]) {
         routingPath.forEach((desc) => {
-            const newPeerId = PeerID.fromValue(desc.kademliaId)
+            const newPeerId = PeerID.fromValue(desc.nodeId)
             if (!this.localPeerId.equals(newPeerId)) {
                 this.allKnownHops.add(newPeerId.toKey())
             }
@@ -114,7 +119,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
     }
 
     private setHopAsReported(desc: PeerDescriptor) {
-        const newPeerId = PeerID.fromValue(desc.kademliaId)
+        const newPeerId = PeerID.fromValue(desc.nodeId)
         if (!this.localPeerId.equals(newPeerId)) {
             this.reportedHops.add(newPeerId.toKey())
         }
@@ -132,11 +137,11 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     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)
+            const creatorKey = keyFromPeerDescriptor(entry.creator!)
+            const existingEntry = this.foundData.get(creatorKey)
+            if (!existingEntry || existingEntry.createdAt! < entry.createdAt! 
+                || (existingEntry.createdAt! <= entry.createdAt! && entry.deleted)) {
+                this.foundData.set(creatorKey, entry)
             }
         })
     }
@@ -164,7 +169,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     public getResults = (): FindResult => ({
         closestNodes: this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()),
-        dataEntries: (this.foundData && this.foundData.size > 0) ? Array.from(this.foundData.values()) : undefined
+        dataEntries: Array.from(this.foundData.values())
     })
 
     public stop(): void {

package/src/dht/find/FindSessionRpcLocal.ts

@@ -6,7 +6,7 @@ import { Logger } from '@streamr/utils'
 const logger = new Logger(module)
 
 interface FindSessionRpcLocalConfig {
-    doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound?: boolean) => void
+    doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => void
 }
 
 export class FindSessionRpcLocal implements IFindSessionRpc {

package/src/dht/find/FindSessionRpcRemote.ts

@@ -5,11 +5,11 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { IFindSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
-import { Remote } from '../contact/Remote'
+import { RpcRemote } from '../contact/RpcRemote'
 
 const logger = new Logger(module)
 
-export class FindSessionRpcRemote extends Remote<IFindSessionRpcClient> {
+export class FindSessionRpcRemote extends RpcRemote<IFindSessionRpcClient> {
 
     sendFindResponse(
         routingPath: PeerDescriptor[],