@streamr/dht 102.0.0-beta.0 → 102.0.0-beta.2

package/src/dht/contact/RandomContactList.ts

@@ -1,56 +0,0 @@
-import { DhtAddress } from '../../identifiers'
-import { ContactList } from './ContactList'
-
-export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extends ContactList<C> {
-
-    private randomness: number
-
-    constructor(
-        localNodeId: DhtAddress,
-        maxSize: number,
-        randomness = 0.20
-    ) {
-        super(localNodeId, maxSize)
-        this.randomness = randomness
-    }
-
-    addContact(contact: C): void {
-        if (this.localNodeId === contact.getNodeId()) {
-            return
-        }
-        if (!this.contactsById.has(contact.getNodeId())) {
-            const roll = Math.random()
-            if (roll < this.randomness) {
-                if (this.getSize() === this.maxSize && this.getSize() > 0) {
-                    const toRemove = this.contactIds[0]
-                    this.removeContact(toRemove)
-                }
-                this.contactIds.push(contact.getNodeId())
-                this.contactsById.set(contact.getNodeId(), contact)
-                this.emit(
-                    'contactAdded',
-                    contact
-                )
-            }
-        }
-    }
-
-    removeContact(id: DhtAddress): boolean {
-        if (this.contactsById.has(id)) {
-            const removed = this.contactsById.get(id)!
-            const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
-            this.contactIds.splice(index, 1)
-            this.contactsById.delete(id)
-            this.emit('contactRemoved', removed)
-            return true
-        }
-        return false
-    }
-
-    public getContacts(limit?: number): C[] {
-        const items = (limit === undefined)
-            ? this.contactIds
-            : this.contactIds.slice(0, Math.max(limit, 0))
-        return items.map((contactId) => this.contactsById.get(contactId)!)
-    }
-}

package/src/dht/contact/RingContactList.ts

@@ -1,143 +0,0 @@
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { OrderedMap } from '@js-sdsl/ordered-map'
-import { RingDistance, RingId, RingIdRaw, getLeftDistance, getRightDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from './ringIdentifiers'
-import { DhtAddress, toNodeId } from '../../identifiers'
-import EventEmitter from 'eventemitter3'
-import { Events } from './ContactList'
-
-export interface RingContacts { 
-    left: PeerDescriptor[]
-    right: PeerDescriptor[]
-}
-
-export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }> extends EventEmitter<Events<C>> {
-
-    private readonly numNeighborsPerSide = 5
-    private readonly referenceId: RingId
-    private readonly excludedIds: Set<DhtAddress>
-    private readonly leftNeighbors: OrderedMap<RingDistance, C>
-    private readonly rightNeighbors: OrderedMap<RingDistance, C>
-
-    constructor(rawReferenceId: RingIdRaw, excludedIds?: Set<DhtAddress>) {
-        super()
-        this.referenceId = getRingIdFromRaw(rawReferenceId)
-        this.excludedIds = excludedIds ?? new Set()
-        this.leftNeighbors = new OrderedMap<RingDistance, C>()
-        this.rightNeighbors = new OrderedMap<RingDistance, C>()
-    }
-
-    addContact(contact: C): void {
-        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
-        if (id === this.referenceId || this.excludedIds.has(toNodeId(contact.getPeerDescriptor()))) {
-            return
-        }
-        let elementAdded = false
-        let elementRemoved = false
-
-        const leftDistance = getLeftDistance(this.referenceId, id)
-        const lastLeftNeighbor = this.leftNeighbors.back()
-        if (lastLeftNeighbor === undefined || leftDistance < lastLeftNeighbor[0]) {
-            this.leftNeighbors.setElement(leftDistance, contact)
-            elementAdded = true
-            if (this.leftNeighbors.size() > this.numNeighborsPerSide) {
-                this.leftNeighbors.eraseElementByIterator(this.leftNeighbors.rBegin())
-                elementRemoved = true
-            }
-        }
-
-        const rightDistance = getRightDistance(this.referenceId, id)
-        const lastRightNeighbor = this.rightNeighbors.back()
-        if (lastRightNeighbor === undefined || rightDistance < lastRightNeighbor[0]) {
-            this.rightNeighbors.setElement(rightDistance, contact)
-            elementAdded = true
-            if (this.rightNeighbors.size() > this.numNeighborsPerSide) {
-                this.rightNeighbors.eraseElementByIterator(this.rightNeighbors.rBegin())
-                elementRemoved = true
-            }
-        }
-
-        if (this.hasEventListeners() && (elementAdded || elementRemoved)) {
-            if (elementAdded) {
-                this.emit('contactAdded', contact)
-            }
-            if (elementRemoved) {
-                this.emit('contactRemoved', contact)
-            }
-        }
-    }
-
-    removeContact(contact?: C): void {
-        if (contact === undefined) {
-            return
-        }
-
-        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
-        const leftDistance = getLeftDistance(this.referenceId, id)
-        const rightDistance = getRightDistance(this.referenceId, id)
-
-        let elementRemoved = false
-        if (this.leftNeighbors.eraseElementByKey(leftDistance)) {
-            elementRemoved = true
-        }
-        if (this.rightNeighbors.eraseElementByKey(rightDistance)) {
-            elementRemoved = true
-        }
-
-        if (this.hasEventListeners() && elementRemoved) {
-            this.emit('contactRemoved', contact)
-        }
-    }
-
-    getContact(peerDescriptor: PeerDescriptor): C | undefined {
-        const id = getRingIdFromPeerDescriptor(peerDescriptor)
-        const leftDistance = getLeftDistance(this.referenceId, id)
-        const rightDistance = getRightDistance(this.referenceId, id)
-        if (this.leftNeighbors.getElementByKey(leftDistance)) {
-            return this.leftNeighbors.getElementByKey(leftDistance)
-        }
-        if (this.rightNeighbors.getElementByKey(rightDistance)) {
-            return this.rightNeighbors.getElementByKey(rightDistance)
-        }
-        return undefined
-    }
-
-    getClosestContacts(limitPerSide?: number): { left: C[], right: C[] } {
-        const leftContacts: C[] = []
-        const rightContacts: C[] = []
-
-        let leftCount = 0
-        for (const item of this.leftNeighbors) {
-            if (limitPerSide != undefined && leftCount >= limitPerSide) {
-                break
-            }
-            leftContacts.push(item[1])
-            leftCount++
-        } 
-
-        let rightCount = 0
-        for (const item of this.rightNeighbors) {
-            if (limitPerSide != undefined && rightCount >= limitPerSide) {
-                break
-            }
-            rightContacts.push(item[1])
-            rightCount++
-        }
-
-        return { left: leftContacts, right: rightContacts }
-    }
-
-    getAllContacts(): C[] {
-        const ret: C[] = []
-        for (const item of this.leftNeighbors) {
-            ret.push(item[1])
-        }
-        for (const item of this.rightNeighbors) {
-            ret.push(item[1])
-        }
-        return ret
-    }
-
-    private hasEventListeners(): boolean {
-        return this.eventNames().length > 0
-    }
-}

package/src/dht/contact/RpcRemote.ts

@@ -1,72 +0,0 @@
-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 '../../../generated/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
-// Requires a WebsocketConnectionRequest to be routed to the client before the connection can be opened
-// takes a little bit longer than WEBSOCKET_CLIENT
-const WEBSOCKET_SERVER_TIMEOUT = 7500
-// WebRTC connections require lots of signalling to open and might take a longer time.
-const WEBRTC_TIMEOUT = 10000
-// default timeout for existing connections
-export const EXISTING_CONNECTION_TIMEOUT = 5000
-
-const getTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor): number => {
-    const connectionType = expectedConnectionType(localPeerDescriptor, remotePeerDescriptor)
-    if (connectionType === ConnectionType.WEBSOCKET_CLIENT) {
-        return WEBSOCKET_CLIENT_TIMEOUT
-    } else if (connectionType === ConnectionType.WEBSOCKET_SERVER) {
-        return WEBSOCKET_SERVER_TIMEOUT
-    } else if (connectionType === ConnectionType.WEBRTC) {
-        return WEBRTC_TIMEOUT
-    }
-    return WEBRTC_TIMEOUT
-}
-
-export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
-
-    private readonly localPeerDescriptor: PeerDescriptor
-    private readonly remotePeerDescriptor: PeerDescriptor
-    private readonly client: ProtoRpcClient<T>
-    private readonly timeout?: number
-
-    constructor(
-        localPeerDescriptor: PeerDescriptor,
-        remotePeerDescriptor: PeerDescriptor,
-        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 = toProtoRpcClient(new clientClass(rpcCommunicator.getRpcClientTransport()))
-        this.timeout = timeout
-    }
-
-    getPeerDescriptor(): PeerDescriptor {
-        return this.remotePeerDescriptor
-    }
-
-    getLocalPeerDescriptor(): PeerDescriptor {
-        return this.localPeerDescriptor
-    }
-
-    getClient(): ProtoRpcClient<T> {
-        return this.client
-    }
-
-    formDhtRpcOptions(opts?: Omit<DhtRpcOptions, 'sourceDescriptor' | 'targetDescriptor'>): DhtRpcOptions {
-        return {
-            sourceDescriptor: this.localPeerDescriptor,
-            targetDescriptor: this.remotePeerDescriptor,
-            timeout: this.timeout ?? getTimeout(this.localPeerDescriptor, this.remotePeerDescriptor),
-            ...opts
-        }
-    }
-}

package/src/dht/contact/SortedContactList.ts

@@ -1,173 +0,0 @@
-import { Events } from './ContactList'
-import { sortedIndexBy } from 'lodash'
-import EventEmitter from 'eventemitter3'
-import { getDistance } from '../PeerManager'
-import { DhtAddress, toDhtAddressRaw } from '../../identifiers'
-
-// add other getters in the future if needed
-export type ReadonlySortedContactList<C extends { getNodeId: () => DhtAddress }> =
-    Pick<SortedContactList<C>, 'getClosestContacts' | 'getAllContactsInUndefinedOrder'>
-
-export interface SortedContactListOptions {
-    referenceId: DhtAddress  // all contacts in this list are in sorted by the distance to this ID
-    allowToContainReferenceId: 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 { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
-
-    private options: SortedContactListOptions
-    private contactsById: Map<DhtAddress, C> = new Map()
-    private contactIds: DhtAddress[] = []
-
-    constructor(
-        options: SortedContactListOptions
-    ) {
-        super()
-        this.options = options
-        this.compareIds = this.compareIds.bind(this)
-    }
-
-    public getClosestContactId(): DhtAddress {
-        return this.contactIds[0]
-    }
-
-    public getContactIds(): DhtAddress[] {
-        return this.contactIds
-    }
-
-    public addContact(contact: C): void {
-        const contactId = contact.getNodeId()
-        if (this.options.excludedNodeIds !== undefined && this.options.excludedNodeIds.has(contactId)) {
-            return
-        }
-        if ((!this.options.allowToContainReferenceId && (this.options.referenceId === contactId)) ||
-            (this.options.nodeIdDistanceLimit !== undefined && this.compareIds(this.options.nodeIdDistanceLimit, contactId) < 0)) {
-            return
-        }
-        if (!this.contactsById.has(contactId)) {
-            if ((this.options.maxSize === undefined) || (this.contactIds.length < this.options.maxSize)) {
-                this.contactsById.set(contactId, contact)
-                const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
-                this.contactIds.splice(index, 0, contactId)
-                if (this.hasEventListeners()) {
-                    this.emit(
-                        'contactAdded',
-                        contact
-                    )
-                }
-            } else if (this.compareIds(this.contactIds[this.options.maxSize - 1], contactId) > 0) {
-                const removedId = this.contactIds.pop()
-                const removedContact = this.contactsById.get(removedId!)!
-                this.contactsById.delete(removedId!)
-                this.contactsById.set(contactId, contact)
-                const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
-                this.contactIds.splice(index, 0, contactId)
-                if (this.hasEventListeners()) {
-                    this.emit(
-                        'contactRemoved',
-                        removedContact
-                    )
-                    this.emit(
-                        'contactAdded',
-                        contact
-                    )
-                }
-            }
-        }
-    }
-
-    public addContacts(contacts: C[]): void {
-        contacts.forEach((contact) => this.addContact(contact))
-    }
-
-    public getContact(id: DhtAddress): C | undefined {
-        return this.contactsById.get(id)
-    }
-
-    has(id: DhtAddress): boolean {
-        return this.contactsById.has(id)
-    }
-
-    /*
-     * Closest first then others in ascending distance order
-     */
-    public getClosestContacts(limit?: number): C[] {
-        const limitedContactIds = (limit === undefined) ? this.contactIds : this.contactIds.slice(0, Math.max(limit, 0)) 
-        return limitedContactIds.map((nodeId) => this.contactsById.get(nodeId)!)
-    }
-
-    /*
-     * Furthest first then others in descending distance order
-     */
-    getFurthestContacts(limit?: number): C[] {
-        const ret = [...this.getClosestContacts()].reverse()
-        return (limit === undefined) 
-            ? ret 
-            : ret.slice(0, Math.max(limit, 0))
-    }
-
-    public compareIds(id1: DhtAddress, id2: DhtAddress): number {
-        const distance1 = this.distanceToReferenceId(id1)
-        const distance2 = this.distanceToReferenceId(id2)
-        return distance1 - distance2
-    }
-
-    // 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(toDhtAddressRaw(this.options.referenceId), toDhtAddressRaw(id))
-    }
-
-    public removeContact(id: DhtAddress): boolean {
-        if (this.contactsById.has(id)) {
-            const removed = this.contactsById.get(id)!
-            // TODO use sortedIndexBy?
-            const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
-            this.contactIds.splice(index, 1)
-            this.contactsById.delete(id)
-            if (this.hasEventListeners()) {
-                this.emit(
-                    'contactRemoved',
-                    removed
-                )
-            }
-            return true
-        }
-        return false
-    }
-
-    public getAllContactsInUndefinedOrder(): Iterable<C> {
-        return this.contactsById.values()
-    }
-
-    public getSize(excludedNodeIds?: Set<DhtAddress>): number {
-        let excludedCount = 0
-        if (excludedNodeIds !== undefined) {
-            for (const nodeId of excludedNodeIds) {
-                if (this.has(nodeId)) {
-                    excludedCount++
-                }
-            }
-        }
-        return this.contactIds.length - excludedCount
-    }
-
-    public clear(): void {
-        this.contactsById.clear()
-        this.contactIds = []
-    }
-
-    public stop(): void {
-        this.removeAllListeners()
-        this.clear()
-    }
-
-    private hasEventListeners(): boolean {
-        return this.eventNames().length > 0
-    }
-}

package/src/dht/contact/getClosestNodes.ts

@@ -1,24 +0,0 @@
-import { PeerDescriptor } from '../../exports'
-import { DhtAddress } from '../../identifiers'
-import { Contact } from './Contact'
-import { SortedContactList } from './SortedContactList'
-
-export const getClosestNodes = (
-    referenceId: DhtAddress,
-    contacts: Iterable<PeerDescriptor>,
-    opts?: {
-        maxCount?: number
-        excludedNodeIds?: Set<DhtAddress>
-    }
-): PeerDescriptor[] => {
-    const list = new SortedContactList<Contact>({
-        referenceId,
-        allowToContainReferenceId: true,
-        excludedNodeIds: opts?.excludedNodeIds,
-        maxSize: opts?.maxCount
-    })
-    for (const contact of contacts) {
-        list.addContact(new Contact(contact))
-    }
-    return list.getClosestContacts().map((n) => n.getPeerDescriptor())
-}

package/src/dht/contact/ringIdentifiers.ts

@@ -1,62 +0,0 @@
-import { PeerDescriptor } from '../../../generated/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,129 +0,0 @@
-import { Gate, Logger, withTimeout } from '@streamr/utils'
-import { v4 } from 'uuid'
-import { DhtAddress, toNodeId, toDhtAddressRaw } from '../../identifiers'
-import { PeerDescriptor } from '../../../generated/packages/dht/protos/DhtRpc'
-import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { PeerManager, getDistance } from '../PeerManager'
-import { getClosestNodes } from '../contact/getClosestNodes'
-
-const logger = new Logger(module)
-
-interface DiscoverySessionOptions {
-    targetId: DhtAddress
-    parallelism: number
-    noProgressLimit: number
-    peerManager: PeerManager
-    // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
-    contactedPeers: Set<DhtAddress>
-    abortSignal: AbortSignal
-    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
-}
-
-export class DiscoverySession {
-
-    public readonly id = v4()
-    private noProgressCounter = 0
-    private ongoingRequests: Set<DhtAddress> = new Set()
-    private doneGate = new Gate(false)
-    private readonly options: DiscoverySessionOptions
-
-    constructor(options: DiscoverySessionOptions) {
-        this.options = options
-    }
-
-    private addContacts(contacts: PeerDescriptor[]): void {
-        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
-            return
-        }
-        for (const contact of contacts) {
-            this.options.peerManager.addContact(contact)
-        }
-    }
-
-    private async fetchClosestNeighborsFromRemote(peerDescriptor: PeerDescriptor): Promise<PeerDescriptor[]> {
-        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
-            return []
-        }
-        const nodeId = toNodeId(peerDescriptor)
-        logger.trace(`Getting closest neighbors from remote: ${nodeId}`)
-        this.options.contactedPeers.add(nodeId)
-        const remote = this.options.createDhtNodeRpcRemote(peerDescriptor)
-        const returnedContacts = await remote.getClosestPeers(this.options.targetId)
-        this.options.peerManager.setContactActive(nodeId)
-        return returnedContacts
-    }
-
-    private onRequestSucceeded(nodeId: DhtAddress, contacts: PeerDescriptor[]) {
-        if (!this.ongoingRequests.has(nodeId)) {
-            return
-        }
-        this.ongoingRequests.delete(nodeId)
-        const targetId = toDhtAddressRaw(this.options.targetId)
-        const oldClosestNeighbor = this.getClosestNeighbor()
-        const oldClosestDistance = getDistance(targetId, oldClosestNeighbor.nodeId)
-        this.addContacts(contacts)
-        const newClosestNeighbor = this.getClosestNeighbor()
-        const newClosestDistance = getDistance(targetId, newClosestNeighbor.nodeId)
-        if (newClosestDistance >= oldClosestDistance) {
-            this.noProgressCounter++
-        }
-    }
-
-    private getClosestNeighbor(): PeerDescriptor {
-        return getClosestNodes(
-            this.options.targetId,
-            this.options.peerManager.getNeighbors().map((n) => n.getPeerDescriptor()),
-            { maxCount: 1 }
-        )[0]
-    }
-
-    private onRequestFailed(nodeId: DhtAddress) {
-        if (!this.ongoingRequests.has(nodeId)) {
-            return
-        }
-        this.ongoingRequests.delete(nodeId)
-        this.options.peerManager.removeContact(nodeId)
-    }
-
-    private findMoreContacts(): void {
-        if (this.options.abortSignal.aborted || this.doneGate.isOpen()) {
-            return
-        }
-        const uncontacted = getClosestNodes(
-            this.options.targetId,
-            Array.from(this.options.peerManager.getNearbyContacts().getAllContactsInUndefinedOrder(), (c) => c.getPeerDescriptor()), 
-            {
-                maxCount: this.options.parallelism,
-                excludedNodeIds: this.options.contactedPeers
-            }
-        )
-        if ((uncontacted.length === 0 && this.ongoingRequests.size === 0) || (this.noProgressCounter >= this.options.noProgressLimit)) {
-            this.doneGate.open()
-            return
-        }
-        for (const node of uncontacted) {
-            if (this.ongoingRequests.size >= this.options.parallelism) {
-                break
-            }
-            const nodeId = toNodeId(node)
-            this.ongoingRequests.add(nodeId)
-            // eslint-disable-next-line promise/catch-or-return
-            this.fetchClosestNeighborsFromRemote(node)
-                .then((contacts) => this.onRequestSucceeded(nodeId, contacts))
-                .catch(() => this.onRequestFailed(nodeId))
-                .finally(() => {
-                    this.findMoreContacts()
-                })
-        }
-    }
-
-    public async findClosestNodes(timeout: number): Promise<void> {
-        if (this.options.peerManager.getNearbyContactCount(this.options.contactedPeers) === 0) {
-            return
-        }
-        setImmediate(() => {
-            this.findMoreContacts()
-        })
-        await withTimeout(this.doneGate.waitUntilOpen(), timeout, 'discovery session timed out', this.options.abortSignal)
-    }
-}