@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/src/dht/contact/{Remote.ts → RpcRemote.ts}

@@ -1,9 +1,10 @@
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
-import { ServiceID } from '../../types/ServiceID'
+import type { ServiceInfo } from '@protobuf-ts/runtime-rpc'
+import { ClassType, ClientTransport, ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import { ConnectionType } from '../../connection/IConnection'
 import { expectedConnectionType } from '../../helpers/Connectivity'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext' 
 
 // Should connect directly to the server, timeout can be low
 const WEBSOCKET_CLIENT_TIMEOUT = 5000
@@ -15,7 +16,7 @@ const WEBRTC_TIMEOUT = 15000
 // default timeout for existing connections
 export const EXISTING_CONNECTION_TIMEOUT = 5000
 
-const getRpcTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): number => {
+const getTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): number => {
     const connectionType = expectedConnectionType(localPeerDescriptor, remotePeerDescriptor)
     if (connectionType === ConnectionType.WEBSOCKET_CLIENT) {
         return WEBSOCKET_CLIENT_TIMEOUT
@@ -27,25 +28,25 @@ const getRpcTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor
     return WEBRTC_TIMEOUT
 }
 
-export abstract class Remote<T> {
+export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
 
     private readonly localPeerDescriptor: PeerDescriptor
     private readonly remotePeerDescriptor: PeerDescriptor
-    private readonly serviceId: ServiceID
     private readonly client: ProtoRpcClient<T>
-    private readonly rpcTimeout?: number
+    private readonly timeout?: number
+
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        serviceId: ServiceID,
-        client: ProtoRpcClient<T>,
-        rpcTimeout?: number
+        rpcCommunicator: RpcCommunicator<DhtCallContext>,
+        // eslint-disable-next-line @typescript-eslint/prefer-function-type
+        clientClass: { new (clientTransport: ClientTransport): T },
+        timeout?: number
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.remotePeerDescriptor = remotePeerDescriptor
-        this.client = client
-        this.serviceId = serviceId
-        this.rpcTimeout = rpcTimeout
+        this.client = toProtoRpcClient(new clientClass(rpcCommunicator.getRpcClientTransport()))
+        this.timeout = timeout
     }
 
     getPeerDescriptor(): PeerDescriptor {
@@ -56,10 +57,6 @@ export abstract class Remote<T> {
         return this.localPeerDescriptor
     }
 
-    getServiceId(): string {
-        return this.serviceId
-    }
-
     getClient(): ProtoRpcClient<T> {
         return this.client
     }
@@ -68,7 +65,7 @@ export abstract class Remote<T> {
         return {
             sourceDescriptor: this.localPeerDescriptor,
             targetDescriptor: this.remotePeerDescriptor,
-            timeout: this.rpcTimeout ?? getRpcTimeout(this.localPeerDescriptor, this.remotePeerDescriptor),
+            timeout: this.timeout ?? getTimeout(this.localPeerDescriptor, this.remotePeerDescriptor),
             ...opts
         }
     }

package/src/dht/contact/SortedContactList.ts

@@ -1,69 +1,86 @@
-import KBucket from 'k-bucket'
-import { PeerID } from '../../helpers/PeerID'
-import { ContactList, ContactState } from './ContactList'
+import { ContactState, Events } from './ContactList'
+import { sortedIndexBy } from 'lodash'
+import EventEmitter from 'eventemitter3'
+import { getDistance } from '../PeerManager'
+import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
+
+export interface SortedContactListConfig {
+    referenceId: DhtAddress  // 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
+    nodeIdDistanceLimit?: DhtAddress
+    // if set, the list can't contain contacts with these ids
+    excludedNodeIds?: Set<DhtAddress>
+}
 
-export class SortedContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
+export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
 
-    private allowLocalPeerId: boolean
-    private peerIdDistanceLimit?: PeerID
-    private excludedPeerIDs?: PeerID[]
+    private config: SortedContactListConfig
+    private contactsById: Map<DhtAddress, ContactState<C>> = new Map()
+    private contactIds: DhtAddress[] = []
 
     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 {
+    public getClosestContactId(): DhtAddress {
         return this.contactIds[0]
     }
 
-    public getContactIds(): PeerID[] {
+    public getContactIds(): DhtAddress[] {
         return this.contactIds
     }
 
     public addContact(contact: C): void {
-        if (this.excludedPeerIDs
-            && this.excludedPeerIDs.some((peerId) => contact.getPeerId().equals(peerId))) {
+        const contactId = contact.getNodeId()
+        if (this.config.excludedNodeIds !== undefined && this.config.excludedNodeIds.has(contactId)) {
             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 === contactId)) ||
+            (this.config.nodeIdDistanceLimit !== undefined && this.compareIds(this.config.nodeIdDistanceLimit, contactId) < 0)) {
             return
         }
-        if (!this.contactsById.has(contact.getPeerId().toKey())) {
-            if (this.contactIds.length < this.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) {
+        if (!this.contactsById.has(contactId)) {
+            if ((this.config.maxSize === undefined) || (this.contactIds.length < this.config.maxSize)) {
+                this.contactsById.set(contactId, new ContactState(contact))
+                const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contactId)
+                if (this.config.emitEvents) {
+                    this.emit(
+                        'contactAdded',
+                        contact,
+                        this.getClosestContacts()
+                    )
+                }
+            } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contactId) > 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)
-                this.emit(
-                    'contactRemoved',
-                    removedContact,
-                    this.getClosestContacts()
-                )
+                const removedContact = this.contactsById.get(removedId!)!.contact
+                this.contactsById.delete(removedId!)
+                this.contactsById.set(contactId, new ContactState(contact))
+                const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contactId)
+                if (this.config.emitEvents) {
+                    const closestContacts = this.getClosestContacts()
+                    this.emit(
+                        'contactRemoved',
+                        removedContact,
+                        closestContacts
+                    )
+                    this.emit(
+                        'contactAdded',
+                        contact,
+                        closestContacts
+                    )
+                }
             }
-            this.emit(
-                'newContact',
-                contact,
-                this.getClosestContacts()
-            )
         }
     }
 
@@ -71,33 +88,41 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         contacts.forEach((contact) => this.addContact(contact))
     }
 
-    public setContacted(contactId: PeerID): void {
-        if (this.contactsById.has(contactId.toKey())) {
-            this.contactsById.get(contactId.toKey())!.contacted = true
+    public getContact(id: DhtAddress): ContactState<C> | undefined {
+        return this.contactsById.get(id)
+    }
+
+    public setContacted(contactId: DhtAddress): void {
+        if (this.contactsById.has(contactId)) {
+            this.contactsById.get(contactId)!.contacted = true
         }
     }
 
-    public setActive(contactId: PeerID): void {
-        if (this.contactsById.has(contactId.toKey())) {
-            this.contactsById.get(contactId.toKey())!.active = true
+    public setActive(contactId: DhtAddress): void {
+        if (this.contactsById.has(contactId)) {
+            this.contactsById.get(contactId)!.active = true
         }
     }
 
-    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())
+            const contact = this.contactsById.get(contactId)
             if (contact) {
                 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[] {
         const ret: C[] = []
         for (const contactId of this.contactIds) {
-            const contact = this.contactsById.get(contactId.toKey())
+            const contact = this.contactsById.get(contactId)
             if (contact && !contact.contacted) {
                 ret.push(contact.contact)
                 if (ret.length >= num) {
@@ -111,7 +136,7 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     public getActiveContacts(limit?: number): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
-            const contact = this.contactsById.get(contactId.toKey())
+            const contact = this.contactsById.get(contactId)
             if (contact && contact.active) {
                 ret.push(contact.contact)
             }
@@ -123,33 +148,56 @@ 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)
+    public compareIds(id1: DhtAddress, id2: DhtAddress): number {
+        const distance1 = this.distanceToReferenceId(id1)
+        const distance2 = this.distanceToReferenceId(id2)
         return distance1 - distance2
     }
 
-    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))
+    // TODO inline this method?
+    private distanceToReferenceId(id: DhtAddress): number {
+        // TODO maybe this class should store the referenceId also as DhtAddressRaw so that we don't need to convert it here?
+        return getDistance(getRawFromDhtAddress(this.config.referenceId), getRawFromDhtAddress(id))
+    }
+
+    public removeContact(id: DhtAddress): boolean {
+        if (this.contactsById.has(id)) {
+            const removed = this.contactsById.get(id)!.contact
+            // TODO use sortedIndexBy?
+            const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
             this.contactIds.splice(index, 1)
-            this.contactsById.delete(id.toKey())
-            this.emit(
-                'contactRemoved',
-                removed,
-                this.getClosestContacts()
-            )
+            this.contactsById.delete(id)
+            if (this.config.emitEvents) {
+                this.emit(
+                    'contactRemoved',
+                    removed,
+                    this.getClosestContacts()
+                )
+            }
             return true
         }
         return false
     }
 
-    public isActive(id: PeerID): boolean {
-        return this.contactsById.has(id.toKey()) ? this.contactsById.get(id.toKey())!.active : false
+    public isActive(id: DhtAddress): boolean {
+        return this.contactsById.has(id) ? this.contactsById.get(id)!.active : false
     }
 
     public getAllContacts(): C[] {
-        return this.contactIds.map((peerId) => this.contactsById.get(peerId.toKey())!.contact)
+        return this.contactIds.map((nodeId) => this.contactsById.get(nodeId)!.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/contact/ringIdentifiers.ts

@@ -0,0 +1,62 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+
+// Notice: you cannot convert RingId to RingIdRaw, because 
+// RingId is only an approximation of the actual value.
+// That is why RingIdRaw is widely used in the codebase.
+
+export type RingIdRaw = Uint8Array & { __ringIdRaw: never }
+export type RingId = number & { __ringId: never }
+export type RingDistance = number & { __ringDistance: never }
+
+export const RING_SIZE = 2 ** 120 - 1   // 2^120 - 1
+
+const binaryToBigInt = (binary: Uint8Array): bigint => {
+    return binary.reduce((acc, val) => (acc << BigInt(8)) | BigInt(val), BigInt(0))
+}
+
+export const getRingIdFromRaw = (raw: RingIdRaw): RingId => Number(binaryToBigInt(raw)) as RingId
+
+export const getRingIdRawFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingIdRaw => {
+    const regionAsBuffer = Buffer.alloc(4)
+    regionAsBuffer.writeUInt32BE(peerDescriptor.region ?? 0, 0)
+    const ipAsbuffer = Buffer.alloc(4)
+    ipAsbuffer.writeUInt32BE(peerDescriptor.ipAddress ?? 0, 0)
+    
+    const uniquePartAsBuffer = Buffer.from(peerDescriptor.nodeId.subarray(peerDescriptor.nodeId.length - 7, peerDescriptor.nodeId.length))
+
+    const arr = [
+        regionAsBuffer,
+        ipAsbuffer,
+        uniquePartAsBuffer
+    ]
+
+    const buffer = Buffer.concat(arr)
+    return new Uint8Array(buffer) as RingIdRaw
+}
+
+export const getRingIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingId => {
+    const raw = getRingIdRawFromPeerDescriptor(peerDescriptor)
+    return Number(binaryToBigInt(raw)) as RingId    
+}
+
+export const getLeftDistance = (referenceId: RingId, id: RingId): RingDistance =>{
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the difference
+        return diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    }
+}
+
+export const getRightDistance = (referenceId: RingId, id: RingId): RingDistance => {
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the difference
+        return diff as RingDistance
+    }
+}

package/src/dht/discovery/DiscoverySession.ts

@@ -1,15 +1,10 @@
-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 { 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 { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -18,53 +13,32 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    bucket: KBucket<DhtNodeRpcRemote>
-    neighborList: SortedContactList<DhtNodeRpcRemote>
-    targetId: Uint8Array
-    localPeerDescriptor: PeerDescriptor
-    serviceId: ServiceID
-    rpcCommunicator: RpcCommunicator
+    targetId: DhtAddress
     parallelism: number
     noProgressLimit: number
-    newContactListener?: (rpcRemote: DhtNodeRpcRemote) => void
-    rpcRequestTimeout?: number
+    peerManager: PeerManager
+    // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
+    contactedPeers: Set<DhtAddress>
 }
 
 export class DiscoverySession {
-    public readonly sessionId = v4()
 
+    public readonly id = v4()
     private stopped = false
     private emitter = new EventEmitter<DiscoverySessionEvents>()
-    private outgoingClosestPeersRequestsCounter = 0
     private noProgressCounter = 0
-    private ongoingClosestPeersRequests: Set<string> = new Set()
+    private ongoingClosestPeersRequests: Set<DhtAddress> = new Set()
     private readonly config: DiscoverySessionConfig
 
     constructor(config: DiscoverySessionConfig) {
         this.config = config
     }
 
-    private addNewContacts(contacts: PeerDescriptor[]): void {
+    private addContacts(contacts: PeerDescriptor[]): void {
         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.addContact(contacts)
     }
 
     private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
@@ -72,41 +46,45 @@ export class DiscoverySession {
             return []
         }
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
-        this.outgoingClosestPeersRequestsCounter++
-        this.config.neighborList.setContacted(contact.getPeerId())
+        this.config.contactedPeers.add(contact.getNodeId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
-        this.config.neighborList.setActive(contact.getPeerId())
+        this.config.peerManager.setContactActive(contact.getNodeId())
         return returnedContacts
     }
 
-    private onClosestPeersRequestSucceeded(peerId: PeerID, contacts: PeerDescriptor[]) {
-        if (!this.ongoingClosestPeersRequests.has(peerId.toKey())) {
+    private onClosestPeersRequestSucceeded(nodeId: DhtAddress, contacts: PeerDescriptor[]) {
+        if (!this.ongoingClosestPeersRequests.has(nodeId)) {
             return
         }
-        this.ongoingClosestPeersRequests.delete(peerId.toKey())
-        const oldClosestContact = this.config.neighborList.getClosestContactId()
-        this.addNewContacts(contacts)
-        if (this.config.neighborList.getClosestContactId().equals(oldClosestContact)) {
+        this.ongoingClosestPeersRequests.delete(nodeId)
+        const targetId = getRawFromDhtAddress(this.config.targetId)
+        const oldClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const oldClosestDistance = getDistance(targetId, getRawFromDhtAddress(oldClosestNeighbor.getNodeId()))
+        this.addContacts(contacts)
+        const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const newClosestDistance = getDistance(targetId, getRawFromDhtAddress(newClosestNeighbor.getNodeId()))
+        if (newClosestDistance >= oldClosestDistance) {
             this.noProgressCounter++
-        } else {
-            this.noProgressCounter = 0
         }
     }
 
     private onClosestPeersRequestFailed(peer: DhtNodeRpcRemote) {
-        if (!this.ongoingClosestPeersRequests.has(peer.getPeerId().toKey())) {
+        if (!this.ongoingClosestPeersRequests.has(peer.getNodeId())) {
             return
         }
-        this.ongoingClosestPeersRequests.delete(peer.getPeerId().toKey())
-        this.config.bucket.remove(peer.getPeerId().value)
-        this.config.neighborList.removeContact(peer.getPeerId())
+        this.ongoingClosestPeersRequests.delete(peer.getNodeId())
+        this.config.peerManager.removeContact(peer.getNodeId())
     }
 
     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.config.contactedPeers
+        )
         if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
             this.emitter.emit('discoveryCompleted')
             this.stopped = true
@@ -116,30 +94,27 @@ export class DiscoverySession {
             if (this.ongoingClosestPeersRequests.size >= this.config.parallelism) {
                 break
             }
-            this.ongoingClosestPeersRequests.add(nextPeer.getPeerId().toKey())
+            this.ongoingClosestPeersRequests.add(nextPeer.getNodeId())
             // eslint-disable-next-line promise/catch-or-return
             this.getClosestPeersFromContact(nextPeer)
-                .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getPeerId(), contacts))
+                .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getNodeId(), contacts))
                 .catch(() => this.onClosestPeersRequestFailed(nextPeer))
                 .finally(() => {
-                    this.outgoingClosestPeersRequestsCounter--
                     this.findMoreContacts()
                 })
         }
     }
 
-    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.getContactCount(this.config.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 {