@streamr/dht 100.0.0-testnet-one.0 → 100.0.0-testnet-one.1

package/src/dht/DhtNodeRpcLocal.ts

@@ -1,6 +1,5 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { Logger } from '@streamr/utils'
-import KBucket from 'k-bucket'
 import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
@@ -13,12 +12,11 @@ import {
 } from '../proto/packages/dht/protos/DhtRpc'
 import { IDhtNodeRpc } from '../proto/packages/dht/protos/DhtRpc.server'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
-import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
 
 interface DhtNodeRpcLocalConfig {
-    bucket: KBucket<DhtNodeRpcRemote>
     serviceId: string
     peerDiscoveryQueryBatchSize: number
+    getClosestPeersTo: (nodeId: Uint8Array, limit: number) => PeerDescriptor[]
     addNewContact: (contact: PeerDescriptor) => void
     removeContact: (contact: PeerDescriptor) => void
 }
@@ -36,17 +34,12 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
         this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
         const response = {
-            peers: this.getClosestPeerDescriptors(request.nodeId, this.config.peerDiscoveryQueryBatchSize),
+            peers: this.config.getClosestPeersTo(request.nodeId, this.config.peerDiscoveryQueryBatchSize),
             requestId: request.requestId
         }
         return response
     }
 
-    private getClosestPeerDescriptors(nodeId: Uint8Array, limit: number): PeerDescriptor[] {
-        const closestPeers = this.config.bucket.closest(nodeId, limit)
-        return closestPeers.map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
-    }
-
     async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
         logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {

package/src/dht/PeerManager.ts

@@ -21,7 +21,7 @@ const logger = new Logger(module)
 
 interface PeerManagerConfig {
     numberOfNodesPerKBucket: number
-    maxNeighborListSize: number
+    maxContactListSize: number
     peerDiscoveryQueryBatchSize: number
     ownPeerId: PeerID
     connectionManager: ConnectionManager
@@ -37,14 +37,24 @@ export interface PeerManagerEvents {
     kBucketEmpty: () => void
 }
 
+export const getDistance = (peerId1: Uint8Array, peerId2: Uint8Array): number => {
+    return KBucket.distance(peerId1, peerId2)
+}
+
 export class PeerManager extends EventEmitter<PeerManagerEvents> {
 
-    // TODO make private
-    public bucket?: KBucket<DhtNodeRpcRemote>
-    // TODO make private
+    // Glossary: 
+    // * 'neighbors' are the nodes that are our neighbors according to 
+    //   the protocol of the layer we are in
+    // * 'connections' are the nodes that are connected to this node on Layer0
+    // * 'contacts' are all non-unresponsive nodes that we know about
+
+    // The kademlia k-bucket
+    private bucket?: KBucket<DhtNodeRpcRemote>
+    // Nodes that are connected to this node on Layer0
     public readonly connections: Map<PeerIDKey, DhtNodeRpcRemote> = new Map()
-    // TODO make private
-    public neighborList?: SortedContactList<DhtNodeRpcRemote>
+    // All nodes that we know about
+    private contacts?: SortedContactList<DhtNodeRpcRemote>
     private randomPeers?: RandomContactList<DhtNodeRpcRemote>
     private readonly config: PeerManagerConfig
     private stopped: boolean = false
@@ -61,24 +71,30 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
+
         this.bucket.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
         this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(contact))
         this.bucket.on('added', (contact: DhtNodeRpcRemote) => this.onKBucketAdded(contact))
         this.bucket.on('updated', () => {
             // TODO: Update contact info to the connection manager and reconnect
         })
-        this.neighborList = new SortedContactList(this.config.ownPeerId, this.config.maxNeighborListSize)
-        this.neighborList.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) => {
+        this.contacts = new SortedContactList({
+            referenceId: this.config.ownPeerId, 
+            maxSize: this.config.maxContactListSize,
+            allowToContainReferenceId: false,
+            emitEvents: true
+        })
+        this.contacts.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) => {
             if (this.stopped) {
                 return
             }
             this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
             this.randomPeers!.addContact(this.config.createDhtNodeRpcRemote(removedContact.getPeerDescriptor()))
         })
-        this.neighborList.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+        this.contacts.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.randomPeers = new RandomContactList(this.config.ownPeerId, this.config.maxNeighborListSize)
+        this.randomPeers = new RandomContactList(this.config.ownPeerId, this.config.maxContactListSize)
         this.randomPeers.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
@@ -91,11 +107,16 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList(this.config.ownPeerId, 100)
+        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList({
+            referenceId: this.config.ownPeerId, 
+            maxSize: 100,  // TODO use config option or named constant?
+            allowToContainReferenceId: false,
+            emitEvents: false
+        })
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
         this.config.connectionManager?.weakUnlockConnection(sortedContacts[sortedContacts.length - 1].getPeerDescriptor())
-        this.bucket?.remove(sortedContacts[sortedContacts.length - 1].getPeerId().value)
+        this.bucket?.remove(sortedContacts[sortedContacts.length - 1].getPeerId().value)    
         this.bucket!.add(newContact)
     }
 
@@ -151,9 +172,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     }
 
     private getClosestActiveContactNotInBucket(): DhtNodeRpcRemote | undefined {
-        for (const contactId of this.neighborList!.getContactIds()) {
-            if (!this.bucket!.get(contactId.value) && this.neighborList!.isActive(contactId)) {
-                return this.neighborList!.getContact(contactId)!.contact
+        for (const contactId of this.contacts!.getContactIds()) {
+            if (!this.bucket!.get(contactId.value) && this.contacts!.isActive(contactId)) {
+                return this.contacts!.getContact(contactId)!.contact
             }
         }
         return undefined
@@ -198,7 +219,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
         const peerId = peerIdFromPeerDescriptor(contact)
         this.bucket!.remove(peerId.value)
-        this.neighborList!.removeContact(peerId)
+        this.contacts!.removeContact(peerId)
         this.randomPeers!.removeContact(peerId)
     }
 
@@ -209,46 +230,99 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             this.bucket!.remove(rpcRemote.id)
         })
         this.bucket!.removeAllListeners()
-        this.neighborList!.stop()
+        this.contacts!.stop()
         this.randomPeers!.stop()
         this.connections.clear()
     }
 
+    getClosestNeighborsTo(kademliaId: Uint8Array, limit?: number, excludeSet?: Set<PeerIDKey>): DhtNodeRpcRemote[] {
+        const closest = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: PeerID.fromValue(kademliaId),
+            allowToContainReferenceId: true,
+            emitEvents: false
+        }) 
+        this.bucket!.toArray().map((contact) => closest.addContact(contact))
+        // TODO should set the excludeSet and limit to SortedContactList constructor and remove these line
+        return closest.getClosestContacts(limit).filter((contact) => {
+            if (!excludeSet) {
+                return true
+            } else {
+                return !excludeSet.has(contact.getPeerId().toKey())
+            } 
+        })
+    }
+
+    // TODO reduce copy-paste?
+    getClosestContactsTo(kademliaId: Uint8Array, limit?: number, excludeSet?: Set<PeerIDKey>): DhtNodeRpcRemote[] {
+        const closest = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: PeerID.fromValue(kademliaId),
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+        this.contacts!.getAllContacts().map((contact) => closest.addContact(contact))
+        // TODO should set the excludeSet and limit to SortedContactList constructor and remove these line
+        return closest.getClosestContacts(limit).filter((contact) => {
+            if (!excludeSet) {
+                return true
+            } else {
+                return !excludeSet.has(contact.getPeerId().toKey())
+            } 
+        })
+    }
+
+    getNumberOfContacts(excludeSet?: Set<PeerIDKey>): number {
+        return this.contacts!.getAllContacts().filter((contact) => {
+            if (!excludeSet) {
+                return true
+            } else {
+                return !excludeSet.has(contact.getPeerId().toKey())
+            } 
+        }).length
+    }
+
     getNumberOfConnections(): number {
         return this.connections.size
     }
 
+    getNumberOfNeighbors(): number {
+        return this.bucket!.count()
+    }
+
+    getNeighbors(): PeerDescriptor[] {
+        return this.bucket!.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    }
+
     handlePeerActive(peerId: PeerID): void {
-        this.neighborList!.setActive(peerId)
+        this.contacts!.setActive(peerId)
     }
 
     handlePeerUnresponsive(peerId: PeerID): void {
         this.bucket!.remove(peerId.value)
-        this.neighborList!.removeContact(peerId)
+        this.contacts!.removeContact(peerId)
     }
 
-    handleNewPeers(contacts: PeerDescriptor[], setActive = false): void {
+    handleNewPeers(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
         if (this.stopped) {
             return
         }
-        contacts.forEach((contact) => {
-            if (!PeerID.fromValue(contact.nodeId).equals(this.config.ownPeerId)) {
+        peerDescriptors.forEach((contact) => {
+            const peerId = peerIdFromPeerDescriptor(contact)
+            if (!peerId.equals(this.config.ownPeerId)) {
                 logger.trace(`Adding new contact ${getNodeIdFromPeerDescriptor(contact)}`)
-                const rpcRemote = this.config.createDhtNodeRpcRemote(contact)
-                if ((this.bucket!.get(contact.nodeId) === null)
-                    && (this.neighborList!.getContact(peerIdFromPeerDescriptor(contact)) === undefined)
-                ) {
-                    this.neighborList!.addContact(rpcRemote)
-                    if (setActive) {
-                        const peerId = peerIdFromPeerDescriptor(contact)
-                        this.neighborList!.setActive(peerId)
-                    }
-                    this.bucket!.add(rpcRemote)
-                } else {
-                    this.randomPeers!.addContact(rpcRemote)
+                const remote = this.config.createDhtNodeRpcRemote(contact)
+                const isInBucket = (this.bucket!.get(contact.nodeId) !== null)
+                const isInNeighborList = (this.contacts!.getContact(peerId) !== undefined)
+                if (isInBucket || isInNeighborList) {
+                    this.randomPeers!.addContact(remote)
                 }
-                if (this.neighborList!.getContact(rpcRemote.getPeerId()) !== undefined) {
-                    this.neighborList!.addContact(rpcRemote)
+                if (!isInBucket) {
+                    this.bucket!.add(remote)
+                } 
+                if (!isInNeighborList) {
+                    this.contacts!.addContact(remote)
+                } 
+                if (setActive) {
+                    this.contacts!.setActive(peerId)
                 }
             }
         })

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,12 +1,11 @@
 import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
-import { PeerID } from '../../helpers/PeerID'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { SortedContactList } from '../contact/SortedContactList'
+import { PeerManager, getDistance } from '../PeerManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { PeerManager } from '../PeerManager'
 
 const logger = new Logger(module)
 
@@ -16,7 +15,6 @@ interface DiscoverySessionEvents {
 
 interface DiscoverySessionConfig {
     targetId: Uint8Array
-    localPeerDescriptor: PeerDescriptor
     parallelism: number
     noProgressLimit: number
     peerManager: PeerManager
@@ -31,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
@@ -49,7 +48,7 @@ export class DiscoverySession {
         }
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
-        this.config.peerManager.neighborList!.setContacted(contact.getPeerId())
+        this.contactedPeers.add(contact.getPeerId().toKey())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
         this.config.peerManager.handlePeerActive(contact.getPeerId())
         return returnedContacts
@@ -60,9 +59,12 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peerId.toKey())
-        const oldClosestContact = this.config.peerManager.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.peerManager.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
@@ -81,7 +83,7 @@ export class DiscoverySession {
         if (this.stopped) {
             return
         }
-        const uncontacted = this.config.peerManager.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
@@ -103,18 +105,16 @@ export class DiscoverySession {
         }
     }
 
-    public async findClosestNodes(timeout: number): Promise<SortedContactList<DhtNodeRpcRemote>> {
-        if (this.config.peerManager.neighborList!.getUncontactedContacts(this.config.parallelism).length === 0) {
-            logger.trace('getUncontactedContacts length was 0 in beginning of discovery, neighborList.size: '
-                + this.config.peerManager.neighborList!.getSize())
-            return this.config.peerManager.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.peerManager.neighborList!
     }
 
     public stop(): void {

package/src/dht/discovery/PeerDiscovery.ts

@@ -4,9 +4,9 @@ import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDes
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
 import { ConnectionManager } from '../../connection/ConnectionManager'
+import { PeerManager } from '../PeerManager'
 import { createRandomNodeId } from '../../helpers/nodeId'
 import { ServiceID } from '../../types/ServiceID'
-import { PeerManager } from '../PeerManager'
 
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
@@ -51,8 +51,6 @@ export class PeerDiscovery {
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
         this.config.peerManager.handleNewPeers([entryPointDescriptor])
         const targetId = peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value
-        const closest = this.config.peerManager.bucket!.closest(targetId, this.config.peerDiscoveryQueryBatchSize)
-        this.config.peerManager.neighborList!.addContacts(closest)
         const sessions = [this.createSession(targetId)]
         if (doAdditionalRandomPeerDiscovery) {
             sessions.push(this.createSession(createRandomNodeId()))
@@ -65,7 +63,6 @@ export class PeerDiscovery {
     private createSession(targetId: Uint8Array): DiscoverySession {
         const sessionOptions = {
             targetId,
-            localPeerDescriptor: this.config.localPeerDescriptor,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
             peerManager: this.config.peerManager
@@ -83,7 +80,7 @@ export class PeerDiscovery {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
             if (!this.isStopped()) {
-                if (this.config.peerManager.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)
@@ -103,7 +100,6 @@ export class PeerDiscovery {
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
-            this.config.peerManager.neighborList!.clear()
             await this.joinDht(entryPoint)
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
@@ -128,16 +124,13 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
-        const nodes = this.config.peerManager.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.nodeId)
-            contacts.forEach((contact) => {
-                this.config.peerManager.handleNewPeers([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 {
@@ -158,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/FindSession.ts

@@ -46,7 +46,12 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
         this.nodeIdToFind = config.nodeIdToFind
         this.localPeerId = config.localPeerId
         this.waitedRoutingPathCompletions = config.waitedRoutingPathCompletions
-        this.results = new SortedContactList(PeerID.fromValue(this.nodeIdToFind), 10, undefined, true)
+        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