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

package/src/dht/{DhtPeer.ts → RemoteDhtNode.ts}

@@ -1,7 +1,6 @@
 import { IDhtRpcServiceClient } from '../proto/packages/dht/protos/DhtRpc.client'
 import {
     ClosestPeersRequest,
-    LeaveNotice,
     PeerDescriptor,
     PingRequest
 } from '../proto/packages/dht/protos/DhtRpc'
@@ -9,6 +8,8 @@ import { v4 } from 'uuid'
 import { Logger } from '@streamr/utils'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
 import { Remote } from './contact/Remote'
+import { PeerID } from '../helpers/PeerID'
+import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -18,7 +19,7 @@ export interface KBucketContact {
     vectorClock: number
 }
 
-export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketContact {
+export class RemoteDhtNode extends Remote<IDhtRpcServiceClient> implements KBucketContact {
 
     private static counter = 0
     public vectorClock: number
@@ -32,11 +33,11 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
     ) {
         super(ownPeerDescriptor, peerDescriptor, serviceId, client)
         this.id = this.getPeerId().value
-        this.vectorClock = DhtPeer.counter++
+        this.vectorClock = RemoteDhtNode.counter++
     }
 
     async getClosestPeers(kademliaId: Uint8Array): Promise<PeerDescriptor[]> {
-        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${this.getPeerId().toKey()}`)
+        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: ClosestPeersRequest = {
             kademliaId,
             requestId: v4()
@@ -51,7 +52,7 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
     }
 
     async ping(): Promise<boolean> {
-        logger.trace(`Requesting ping on ${this.getServiceId()} from ${this.getPeerId().toKey()}`)
+        logger.trace(`Requesting ping on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: PingRequest = {
             requestId: v4()
         }
@@ -64,13 +65,15 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
                 return true
             }
         } catch (err) {
-            logger.trace(`ping failed on ${this.getServiceId()} to ${this.getPeerId().toKey()}: ${err}`)
+            logger.trace(`ping failed on ${this.getServiceId()} to ${keyFromPeerDescriptor(this.getPeerDescriptor())}: ${err}`)
         }
         return false
     }
 
+    /*
+    TODO remove or start using this method in NET-1131 
     leaveNotice(): void {
-        logger.trace(`Sending leaveNotice on ${this.getServiceId()} from ${this.getPeerId().toKey()}`)
+        logger.trace(`Sending leaveNotice on ${this.getServiceId()} from ${keyFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: LeaveNotice = {
             serviceId: this.getServiceId()
         }
@@ -80,5 +83,9 @@ export class DhtPeer extends Remote<IDhtRpcServiceClient> implements KBucketCont
         this.getClient().leaveNotice(request, options).catch((e) => {
             logger.trace('Failed to send leaveNotice' + e)
         })
+    }*/
+
+    getPeerId(): PeerID {
+        return peerIdFromPeerDescriptor(this.getPeerDescriptor())
     }
 }

package/src/dht/contact/Contact.ts

@@ -2,24 +2,7 @@ import { PeerID } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
-export class ContactState<TContact> {
-    public contacted = false
-    public active = false
-    public contact: TContact
-
-    constructor(contact: TContact) {
-        this.contact = contact
-    }
-}
-
-export interface IContact { getPeerId: () => PeerID, getPeerDescriptor: () => PeerDescriptor }
-
-export interface Events {
-    contactRemoved: (removedDescriptor: PeerDescriptor, closestDescriptors: PeerDescriptor[]) => void
-    newContact: (newDescriptor: PeerDescriptor, closestDescriptors: PeerDescriptor[]) => void
-}
-
-export class Contact implements IContact {
+export class Contact {
     private peerDescriptor: PeerDescriptor
 
     constructor(peerDescriptor: PeerDescriptor) {

package/src/dht/contact/ContactList.ts

@@ -1,8 +1,22 @@
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import EventEmitter from 'eventemitter3'
-import { Events, IContact, ContactState } from './Contact'
 
-export class ContactList<C extends IContact> extends EventEmitter<Events> {
+export class ContactState<C> {
+    public contacted = false
+    public active = false
+    public contact: C
+
+    constructor(contact: C) {
+        this.contact = contact
+    }
+}
+
+export interface Events<C> {
+    contactRemoved: (removedContact: C, closestContacts: C[]) => void
+    newContact: (newContact: C, closestContacts: C[]) => void
+}
+
+export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
 
     protected contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
     protected contactIds: PeerID[] = []
@@ -25,10 +39,6 @@ export class ContactList<C extends IContact> extends EventEmitter<Events> {
         return this.contactsById.get(id.toKey())!
     }
 
-    public hasContact(id: PeerID): boolean {
-        return this.contactsById.has(id.toKey())
-    }
-
     public getSize(): number {
         return this.contactIds.length
     }

package/src/dht/contact/RandomContactList.ts

@@ -1,8 +1,7 @@
 import { PeerID } from '../../helpers/PeerID'
-import { ContactState, IContact } from './Contact'
-import { ContactList } from './ContactList'
+import { ContactList, ContactState } from './ContactList'
 
-export class RandomContactList<C extends IContact> extends ContactList<C> {
+export class RandomContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
 
     private randomness: number
 
@@ -31,24 +30,20 @@ export class RandomContactList<C extends IContact> extends ContactList<C> {
                 this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
                 this.emit(
                     'newContact',
-                    contact.getPeerDescriptor(),
-                    this.getContacts().map((contact: C) => contact.getPeerDescriptor())
+                    contact,
+                    this.getContacts()
                 )
             }
         }
     }
 
-    addContacts(contacts: C[]): void {
-        contacts.forEach((contact) => this.addContact(contact))
-    }
-
     removeContact(id: PeerID): boolean {
         if (this.contactsById.has(id.toKey())) {
-            const removedDescriptor = this.contactsById.get(id.toKey())!.contact.getPeerDescriptor()
+            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', removedDescriptor, this.getContacts().map((contact: C) => contact.getPeerDescriptor()))
+            this.emit('contactRemoved', removed, this.getContacts())
             return true
         }
         return false

package/src/dht/contact/Remote.ts

@@ -1,14 +1,10 @@
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { PeerID } from '../../helpers/PeerID'
-import { IContact } from './Contact'
 import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
 
-export abstract class Remote<T> implements IContact {
+export abstract class Remote<T> {
 
     private readonly localPeerDescriptor: PeerDescriptor
-    private readonly remotePeerId: PeerID
     private readonly remotePeerDescriptor: PeerDescriptor
     private readonly serviceId: string
     private readonly client: ProtoRpcClient<T>
@@ -20,16 +16,11 @@ export abstract class Remote<T> implements IContact {
         client: ProtoRpcClient<T>
     ) {
         this.localPeerDescriptor = localPeerDescriptor
-        this.remotePeerId = peerIdFromPeerDescriptor(remotePeerDescriptor)
         this.remotePeerDescriptor = remotePeerDescriptor
         this.client = client
         this.serviceId = serviceId
     }
 
-    getPeerId(): PeerID {
-        return this.remotePeerId
-    }
-
     getPeerDescriptor(): PeerDescriptor {
         return this.remotePeerDescriptor
     }

package/src/dht/contact/SortedContactList.ts

@@ -1,9 +1,8 @@
 import KBucket from 'k-bucket'
 import { PeerID } from '../../helpers/PeerID'
-import { ContactState, IContact } from './Contact'
-import { ContactList } from './ContactList'
+import { ContactList, ContactState } from './ContactList'
 
-export class SortedContactList<C extends IContact> extends ContactList<C> {
+export class SortedContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
 
     private allowOwnPeerId: boolean
     private peerIdDistanceLimit?: PeerID
@@ -48,22 +47,22 @@ export class SortedContactList<C extends IContact> extends ContactList<C> {
                 this.contactIds.push(contact.getPeerId())
                 this.contactIds.sort(this.compareIds)
             } else if (this.compareIds(this.contactIds[this.maxSize - 1], contact.getPeerId()) > 0) {
-                const removed = this.contactIds.pop()
-                const removedDescriptor = this.contactsById.get(removed!.toKey())!.contact.getPeerDescriptor()
-                this.contactsById.delete(removed!.toKey())
+                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',
-                    removedDescriptor,
-                    this.getClosestContacts().map((contact: C) => contact.getPeerDescriptor())
+                    removedContact,
+                    this.getClosestContacts()
                 )
             }
             this.emit(
                 'newContact',
-                contact.getPeerDescriptor(),
-                this.getClosestContacts().map((contact: C) => contact.getPeerDescriptor())
+                contact,
+                this.getClosestContacts()
             )
         }
     }
@@ -130,20 +129,16 @@ export class SortedContactList<C extends IContact> extends ContactList<C> {
         return distance1 - distance2
     }
 
-    public getStringIds(): string[] {
-        return this.contactIds.map((peerId) => peerId.toKey())
-    }
-
     public removeContact(id: PeerID): boolean {
         if (this.contactsById.has(id.toKey())) {
-            const removedDescriptor = this.contactsById.get(id.toKey())!.contact.getPeerDescriptor()
+            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',
-                removedDescriptor,
-                this.getClosestContacts().map((contact: C) => contact.getPeerDescriptor())
+                removed,
+                this.getClosestContacts()
             )
             return true
         }
@@ -157,12 +152,4 @@ export class SortedContactList<C extends IContact> extends ContactList<C> {
     public getAllContacts(): C[] {
         return this.contactIds.map((peerId) => this.contactsById.get(peerId.toKey())!.contact)
     }
-
-    public getMaxSize(): number {
-        return this.maxSize
-    }
-
-    public setAllAsUncontacted(): void {
-        this.contactsById.forEach((contact) => contact.contacted = false)
-    }
 }

package/src/dht/discovery/DiscoverySession.ts

@@ -7,8 +7,8 @@ import { PeerID } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { DhtRpcServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { SortedContactList } from '../contact/SortedContactList'
-import { DhtPeer } from '../DhtPeer'
-import { peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { RemoteDhtNode } from '../RemoteDhtNode'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 const logger = new Logger(module)
 
@@ -17,16 +17,15 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    bucket: KBucket<DhtPeer>
-    neighborList: SortedContactList<DhtPeer>
+    bucket: KBucket<RemoteDhtNode>
+    neighborList: SortedContactList<RemoteDhtNode>
     targetId: Uint8Array
     ownPeerDescriptor: PeerDescriptor
     serviceId: string
     rpcCommunicator: RpcCommunicator
     parallelism: number
     noProgressLimit: number
-    newContactListener?: (dhtPeer: DhtPeer) => void
-    nodeName?: string
+    newContactListener?: (remoteDhtNode: RemoteDhtNode) => void
 }
 
 export class DiscoverySession {
@@ -38,11 +37,9 @@ export class DiscoverySession {
     private noProgressCounter = 0
     private ongoingClosestPeersRequests: Set<string> = new Set()
     private readonly config: DiscoverySessionConfig
-    private readonly ownPeerId: PeerID
 
     constructor(config: DiscoverySessionConfig) {
         this.config = config
-        this.ownPeerId = peerIdFromPeerDescriptor(config.ownPeerDescriptor)
     }
 
     private addNewContacts(contacts: PeerDescriptor[]): void {
@@ -50,28 +47,28 @@ export class DiscoverySession {
             return
         }
         contacts.forEach((contact) => {
-            const dhtPeer = new DhtPeer(
-                this.config.ownPeerDescriptor,
-                contact,
-                toProtoRpcClient(new DhtRpcServiceClient(this.config.rpcCommunicator.getRpcClientTransport())),
-                this.config.serviceId
-            )
-            if (!dhtPeer.getPeerId().equals(this.ownPeerId)) {
+            if (!areEqualPeerDescriptors(contact, this.config.ownPeerDescriptor)) {
+                const remoteDhtNode = new RemoteDhtNode(
+                    this.config.ownPeerDescriptor,
+                    contact,
+                    toProtoRpcClient(new DhtRpcServiceClient(this.config.rpcCommunicator.getRpcClientTransport())),
+                    this.config.serviceId
+                )
                 if (this.config.newContactListener) {
-                    this.config.newContactListener(dhtPeer)
+                    this.config.newContactListener(remoteDhtNode)
                 }
-                if (!this.config.neighborList.getContact(dhtPeer.getPeerId())) {
-                    this.config.neighborList.addContact(dhtPeer)
+                if (!this.config.neighborList.getContact(remoteDhtNode.getPeerId())) {
+                    this.config.neighborList.addContact(remoteDhtNode)
                 }
             }
         })
     }
 
-    private async getClosestPeersFromContact(contact: DhtPeer): Promise<PeerDescriptor[]> {
+    private async getClosestPeersFromContact(contact: RemoteDhtNode): Promise<PeerDescriptor[]> {
         if (this.stopped) {
             return []
         }
-        logger.trace(`Getting closest peers from contact: ${contact.getPeerId().toKey()}`)
+        logger.trace(`Getting closest peers from contact: ${keyFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
         this.config.neighborList.setContacted(contact.getPeerId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
@@ -93,7 +90,7 @@ export class DiscoverySession {
         }
     }
 
-    private onClosestPeersRequestFailed(peer: DhtPeer, _exception: Error) {
+    private onClosestPeersRequestFailed(peer: RemoteDhtNode) {
         if (!this.ongoingClosestPeersRequests.has(peer.getPeerId().toKey())) {
             return
         }
@@ -120,7 +117,7 @@ export class DiscoverySession {
             // eslint-disable-next-line promise/catch-or-return
             this.getClosestPeersFromContact(nextPeer)
                 .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getPeerId(), contacts))
-                .catch((err) => this.onClosestPeersRequestFailed(nextPeer, err))
+                .catch(() => this.onClosestPeersRequestFailed(nextPeer))
                 .finally(() => {
                     this.outgoingClosestPeersRequestsCounter--
                     this.findMoreContacts()
@@ -128,7 +125,7 @@ export class DiscoverySession {
         }
     }
 
-    public async findClosestNodes(timeout: number): Promise<SortedContactList<DhtPeer>> {
+    public async findClosestNodes(timeout: number): Promise<SortedContactList<RemoteDhtNode>> {
         if (this.config.neighborList.getUncontactedContacts(this.config.parallelism).length < 1) {
             logger.trace('getUncontactedContacts length was 0 in beginning of discovery, this.neighborList.size: '
                 + this.config.neighborList.getSize())

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,25 +1,24 @@
 import { DiscoverySession } from './DiscoverySession'
-import { DhtPeer } from '../DhtPeer'
-import crypto from 'crypto'
-import { isSamePeerDescriptor, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { RemoteDhtNode } from '../RemoteDhtNode'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, 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 { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { PeerIDKey } from '../../helpers/PeerID'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RandomContactList } from '../contact/RandomContactList'
+import { createRandomKademliaId } from '../../helpers/kademliaId'
 
 interface PeerDiscoveryConfig {
     rpcCommunicator: RoutingRpcCommunicator
     ownPeerDescriptor: PeerDescriptor
-    ownPeerId: PeerID
-    bucket: KBucket<DhtPeer>
-    connections: Map<PeerIDKey, DhtPeer>
-    neighborList: SortedContactList<DhtPeer>
-    randomPeers: RandomContactList<DhtPeer>
-    openInternetPeers: SortedContactList<DhtPeer>
+    bucket: KBucket<RemoteDhtNode>
+    connections: Map<PeerIDKey, RemoteDhtNode>
+    neighborList: SortedContactList<RemoteDhtNode>
+    randomPeers: RandomContactList<RemoteDhtNode>
+    openInternetPeers: SortedContactList<RemoteDhtNode>
     joinNoProgressLimit: number
     getClosestContactsLimit: number
     serviceId: string
@@ -32,12 +31,11 @@ interface PeerDiscoveryConfig {
 const logger = new Logger(module)
 
 export class PeerDiscovery {
+
     private readonly config: PeerDiscoveryConfig
     private ongoingDiscoverySessions: Map<string, DiscoverySession> = new Map()
-    private stopped = false
     private rejoinOngoing = false
     private joinCalled = false
-
     private rejoinTimeoutRef?: NodeJS.Timeout
     private readonly abortController: AbortController
     private recoveryIntervalStarted = false
@@ -47,8 +45,8 @@ export class PeerDiscovery {
         this.abortController = new AbortController()
     }
 
-    async joinDht(entryPointDescriptor: PeerDescriptor, doRandomJoin = true, retry = true): Promise<void> {
-        if (this.stopped) {
+    async joinDht(entryPointDescriptor: PeerDescriptor, doAdditionalRandomPeerDiscovery = true, retry = true): Promise<void> {
+        if (this.isStopped()) {
             return
         }
         this.joinCalled = true
@@ -56,44 +54,47 @@ export class PeerDiscovery {
             `Joining ${this.config.serviceId === 'layer0' ? 'The Streamr Network' : `Control Layer for ${this.config.serviceId}`}`
             + ` via entrypoint ${keyFromPeerDescriptor(entryPointDescriptor)}`
         )
-        if (isSamePeerDescriptor(entryPointDescriptor, this.config.ownPeerDescriptor)) {
+        if (areEqualPeerDescriptors(entryPointDescriptor, this.config.ownPeerDescriptor)) {
             return
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
         this.config.addContact(entryPointDescriptor)
-        const closest = this.config.bucket.closest(this.config.ownPeerId.value, this.config.getClosestContactsLimit)
+        const closest = this.config.bucket.closest(peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value, this.config.getClosestContactsLimit)
         this.config.neighborList.addContacts(closest)
+        const sessions = [this.createSession(peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value)]
+        if (doAdditionalRandomPeerDiscovery) {
+            sessions.push(this.createSession(createRandomKademliaId()))
+        }
+        await this.runSessions(sessions, entryPointDescriptor, retry)
+        this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+
+    }
+
+    private createSession(targetId: Uint8Array): DiscoverySession {
         const sessionOptions = {
             bucket: this.config.bucket,
             neighborList: this.config.neighborList,
-            targetId: this.config.ownPeerId.value,
+            targetId,
             ownPeerDescriptor: this.config.ownPeerDescriptor,
             serviceId: this.config.serviceId,
             rpcCommunicator: this.config.rpcCommunicator,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
-            newContactListener: (newPeer: DhtPeer) => this.config.addContact(newPeer.getPeerDescriptor()),
-            nodeName: this.config.ownPeerDescriptor.nodeName
-        }
-        const session = new DiscoverySession(sessionOptions)
-        const randomSession = doRandomJoin ? new DiscoverySession({
-            ...sessionOptions,
-            targetId: crypto.randomBytes(8),
-            nodeName: this.config.ownPeerDescriptor.nodeName + '-random'
-        }) : null
-        this.ongoingDiscoverySessions.set(session.sessionId, session)
-        if (randomSession) {
-            this.ongoingDiscoverySessions.set(randomSession.sessionId, randomSession)
+            newContactListener: (newPeer: RemoteDhtNode) => this.config.addContact(newPeer.getPeerDescriptor())
         }
+        return new DiscoverySession(sessionOptions)
+    }
+
+    private async runSessions(sessions: DiscoverySession[], entryPointDescriptor: PeerDescriptor, retry: boolean): Promise<void> {
         try {
-            await session.findClosestNodes(this.config.joinTimeout)
-            if (randomSession) {
-                await randomSession.findClosestNodes(this.config.joinTimeout)
+            for (const session of sessions) {
+                this.ongoingDiscoverySessions.set(session.sessionId, session)
+                await session.findClosestNodes(this.config.joinTimeout)
             }
         } catch (_e) {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
-            if (!this.stopped) {
+            if (!this.isStopped()) {
                 if (this.config.bucket.count() === 0) {
                     if (retry) {
                         setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
@@ -102,19 +103,15 @@ export class PeerDiscovery {
                     await this.ensureRecoveryIntervalIsRunning()
                 }
             }
-            this.ongoingDiscoverySessions.delete(session.sessionId)
-            if (randomSession) {
-                this.ongoingDiscoverySessions.delete(randomSession.sessionId)
-            }
-            this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
+            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.sessionId))
         }
     }
 
     public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
-        if (this.stopped || this.rejoinOngoing) {
+        if (this.isStopped() || this.rejoinOngoing) {
             return
         }
-        logger.debug(`Rejoining DHT ${this.config.serviceId} ${this.config.ownPeerDescriptor.nodeName}!`)
+        logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
             this.config.neighborList.clear()
@@ -122,7 +119,7 @@ export class PeerDiscovery {
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
-            if (!this.stopped) {
+            if (!this.isStopped()) {
                 setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.abortController.signal)
             }
         } finally {
@@ -138,10 +135,11 @@ export class PeerDiscovery {
     }
 
     private async fetchClosestPeersFromBucket(): Promise<void> {
-        if (this.stopped) {
+        if (this.isStopped()) {
             return
         }
-        await Promise.allSettled(this.config.bucket.closest(this.config.ownPeerId.value, this.config.parallelism).map(async (peer: DhtPeer) => {
+        const nodes = this.config.bucket.closest(peerIdFromPeerDescriptor(this.config.ownPeerDescriptor).value, this.config.parallelism)
+        await Promise.allSettled(nodes.map(async (peer: RemoteDhtNode) => {
             const contacts = await peer.getClosestPeers(this.config.ownPeerDescriptor.kademliaId)
             contacts.forEach((contact) => {
                 this.config.addContact(contact)
@@ -157,8 +155,11 @@ export class PeerDiscovery {
         return this.joinCalled
     }
 
+    private isStopped() {
+        return this.abortController.signal.aborted
+    }
+
     public stop(): void {
-        this.stopped = true
         this.abortController.abort()
         if (this.rejoinTimeoutRef) {
             clearTimeout(this.rejoinTimeoutRef)