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

package/src/dht/DhtNodeRpcRemote.ts

@@ -8,7 +8,7 @@ import {
 import { v4 } from 'uuid'
 import { Logger } from '@streamr/utils'
 import { ProtoRpcClient } from '@streamr/proto-rpc'
-import { Remote } from './contact/Remote'
+import { RpcRemote } from './contact/RpcRemote'
 import { PeerID } from '../helpers/PeerID'
 import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import { ServiceID } from '../types/ServiceID'
@@ -21,7 +21,7 @@ export interface KBucketContact {
     vectorClock: number
 }
 
-export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBucketContact {
+export class DhtNodeRpcRemote extends RpcRemote<IDhtNodeRpcClient> implements KBucketContact {
 
     private static counter = 0
     public vectorClock: number
@@ -39,10 +39,10 @@ export class DhtNodeRpcRemote extends Remote<IDhtNodeRpcClient> implements KBuck
         this.vectorClock = DhtNodeRpcRemote.counter++
     }
 
-    async getClosestPeers(kademliaId: Uint8Array): Promise<PeerDescriptor[]> {
+    async getClosestPeers(nodeId: Uint8Array): Promise<PeerDescriptor[]> {
         logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
         const request: ClosestPeersRequest = {
-            kademliaId,
+            nodeId,
             requestId: v4()
         }
         try {

package/src/dht/ExternalApiRpcLocal.ts

@@ -4,6 +4,7 @@ import {
     ExternalFindDataResponse,
     ExternalStoreDataRequest,
     ExternalStoreDataResponse,
+    FindAction,
     PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
@@ -12,8 +13,8 @@ import { FindResult } from './find/Finder'
 import { Any } from '../proto/google/protobuf/any'
 
 interface ExternalApiRpcLocalConfig {
-    startFind: (idToFind: Uint8Array, fetchData: boolean, excludedPeer: PeerDescriptor) => Promise<FindResult>
-    storeDataToDht: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
+    startFind: (idToFind: Uint8Array, action: FindAction, excludedPeer: PeerDescriptor) => Promise<FindResult>
+    storeDataToDht: (key: Uint8Array, data: Any, creator: PeerDescriptor) => Promise<PeerDescriptor[]>
 }
 
 export class ExternalApiRpcLocal implements IExternalApiRpc {
@@ -26,19 +27,13 @@ export class ExternalApiRpcLocal implements IExternalApiRpc {
 
     async externalFindData(findDataRequest: ExternalFindDataRequest, context: ServerCallContext): Promise<ExternalFindDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.config.startFind(findDataRequest.kademliaId, true, senderPeerDescriptor)
-        if (result.dataEntries) {
-            return ExternalFindDataResponse.create({ dataEntries: result.dataEntries })
-        } else {
-            return ExternalFindDataResponse.create({ 
-                dataEntries: [],
-                error: 'Could not find data with the given key' 
-            })
-        }
+        const result = await this.config.startFind(findDataRequest.key, FindAction.FETCH_DATA, senderPeerDescriptor)
+        return ExternalFindDataResponse.create({ entries: result.dataEntries ?? [] })
     }
 
-    async externalStoreData(request: ExternalStoreDataRequest): Promise<ExternalStoreDataResponse> {
-        const result = await this.config.storeDataToDht(request.key, request.data!)
+    async externalStoreData(request: ExternalStoreDataRequest, context: ServerCallContext): Promise<ExternalStoreDataResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const result = await this.config.storeDataToDht(request.key, request.data!, senderPeerDescriptor)
         return ExternalStoreDataResponse.create({
             storers: result
         })

package/src/dht/ExternalApiRpcRemote.ts

@@ -1,20 +1,20 @@
 import { Any } from '../proto/google/protobuf/any'
 import { DataEntry, ExternalStoreDataRequest, ExternalFindDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { IExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
-import { Remote } from './contact/Remote'
+import { RpcRemote } from './contact/RpcRemote'
 
-export class ExternalApiRpcRemote extends Remote<IExternalApiRpcClient> {
+export class ExternalApiRpcRemote extends RpcRemote<IExternalApiRpcClient> {
 
-    async externalFindData(idToFind: Uint8Array): Promise<DataEntry[]> {
+    async externalFindData(key: Uint8Array): Promise<DataEntry[]> {
         const request: ExternalFindDataRequest = {
-            kademliaId: idToFind
+            key
         }
         const options = this.formDhtRpcOptions({
             timeout: 10000
         })
         try {
             const data = await this.getClient().externalFindData(request, options)
-            return data.dataEntries
+            return data.entries
         } catch (err) {
             return []
         }

package/src/dht/PeerManager.ts

@@ -0,0 +1,256 @@
+import {
+    Logger
+} from '@streamr/utils'
+import KBucket from 'k-bucket'
+import { PeerID, PeerIDKey } from '../helpers/PeerID'
+import {
+    getNodeIdFromPeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../helpers/peerIdFromPeerDescriptor'
+import {
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+import { DhtNodeRpcRemote } from './DhtNodeRpcRemote'
+import { RandomContactList } from './contact/RandomContactList'
+import { SortedContactList } from './contact/SortedContactList'
+import { ConnectionManager } from '../connection/ConnectionManager'
+import EventEmitter from 'eventemitter3'
+
+const logger = new Logger(module)
+
+interface PeerManagerConfig {
+    numberOfNodesPerKBucket: number
+    maxNeighborListSize: number
+    peerDiscoveryQueryBatchSize: number
+    ownPeerId: PeerID
+    connectionManager: ConnectionManager
+    isLayer0: boolean
+    createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
+}
+
+export interface PeerManagerEvents {
+    newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    newRandomContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    kBucketEmpty: () => void
+}
+
+export class PeerManager extends EventEmitter<PeerManagerEvents> {
+
+    // TODO make private
+    public bucket?: KBucket<DhtNodeRpcRemote>
+    // TODO make private
+    public readonly connections: Map<PeerIDKey, DhtNodeRpcRemote> = new Map()
+    // TODO make private
+    public neighborList?: SortedContactList<DhtNodeRpcRemote>
+    private randomPeers?: RandomContactList<DhtNodeRpcRemote>
+    private readonly config: PeerManagerConfig
+    private stopped: boolean = false
+
+    constructor(config: PeerManagerConfig) {
+        super()
+        this.config = config
+        this.initKBuckets()
+    }
+
+    private initKBuckets() {
+        this.bucket = new KBucket<DhtNodeRpcRemote>({
+            localNodeId: this.config.ownPeerId.value,
+            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[]) => {
+            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.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+        this.randomPeers = new RandomContactList(this.config.ownPeerId, this.config.maxNeighborListSize)
+        this.randomPeers.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+        this.randomPeers.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('newRandomContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        )
+    }
+
+    private onKBucketPing(oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        const sortingList: SortedContactList<DhtNodeRpcRemote> = new SortedContactList(this.config.ownPeerId, 100)
+        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!.add(newContact)
+    }
+
+    private onKBucketRemoved(contact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
+        logger.trace(`Removed contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        if (this.bucket!.count() === 0) {
+            this.emit('kBucketEmpty')
+        }
+    }
+
+    private onKBucketAdded(contact: DhtNodeRpcRemote): void {
+        if (this.stopped) {
+            return
+        }
+        if (!contact.getPeerId().equals(this.config.ownPeerId)) {
+            // Important to lock here, before the ping result is known
+            this.config.connectionManager?.weakLockConnection(contact.getPeerDescriptor())
+            if (this.connections.has(contact.getPeerId().toKey())) {
+                logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+            } else {    // open connection by pinging
+                logger.trace('starting ping ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
+                contact.ping().then((result) => {
+                    if (result) {
+                        logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+                    } else {
+                        logger.trace('ping failed ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
+                        this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
+                        this.removeContact(contact.getPeerDescriptor())
+                        this.addClosestContactToBucket()
+                    }
+                    return
+                }).catch((_e) => {
+                    this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
+                    this.removeContact(contact.getPeerDescriptor())
+                    this.addClosestContactToBucket()
+                })
+            }
+        }
+    }
+
+    private addClosestContactToBucket(): void {
+        if (this.stopped) {
+            return
+        }
+        const closest = this.getClosestActiveContactNotInBucket()
+        if (closest) {
+            this.handleNewPeers([closest.getPeerDescriptor()])
+        }
+    }
+
+    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
+            }
+        }
+        return undefined
+    }
+
+    handleConnected(peerDescriptor: PeerDescriptor): void {
+        if (PeerID.fromValue(peerDescriptor.nodeId).equals(this.config.ownPeerId)) {
+            logger.error('handleConnected() to self')
+        }
+        const rpcRemote = this.config.createDhtNodeRpcRemote(peerDescriptor)
+        if (!this.connections.has(PeerID.fromValue(rpcRemote.id).toKey())) {
+            this.connections.set(PeerID.fromValue(rpcRemote.id).toKey(), rpcRemote)
+            logger.trace('connectionschange add ' + this.connections.size)
+        } else {
+            logger.trace('new connection not set to connections, there is already a connection with the peer ID')
+        }
+        logger.trace('connected: ' + getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
+    }
+
+    handleDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
+        logger.trace('disconnected: ' + getNodeIdFromPeerDescriptor(peerDescriptor))
+        this.connections.delete(keyFromPeerDescriptor(peerDescriptor))
+        if (this.config.isLayer0) {
+            this.bucket!.remove(peerDescriptor.nodeId)
+            if (gracefulLeave === true) {
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                this.removeContact(peerDescriptor)
+            } else {
+                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+            }
+        }
+    }
+
+    handlePeerLeaving(peerDescriptor: PeerDescriptor): void {
+        this.removeContact(peerDescriptor)
+    }
+
+    private removeContact(contact: PeerDescriptor): void {
+        if (this.stopped) {
+            return
+        }
+        logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
+        const peerId = peerIdFromPeerDescriptor(contact)
+        this.bucket!.remove(peerId.value)
+        this.neighborList!.removeContact(peerId)
+        this.randomPeers!.removeContact(peerId)
+    }
+
+    stop(): void {
+        this.stopped = true
+        this.bucket!.toArray().forEach((rpcRemote: DhtNodeRpcRemote) => {
+            rpcRemote.leaveNotice()
+            this.bucket!.remove(rpcRemote.id)
+        })
+        this.bucket!.removeAllListeners()
+        this.neighborList!.stop()
+        this.randomPeers!.stop()
+        this.connections.clear()
+    }
+
+    getNumberOfConnections(): number {
+        return this.connections.size
+    }
+
+    handlePeerActive(peerId: PeerID): void {
+        this.neighborList!.setActive(peerId)
+    }
+
+    handlePeerUnresponsive(peerId: PeerID): void {
+        this.bucket!.remove(peerId.value)
+        this.neighborList!.removeContact(peerId)
+    }
+
+    handleNewPeers(contacts: PeerDescriptor[], setActive = false): void {
+        if (this.stopped) {
+            return
+        }
+        contacts.forEach((contact) => {
+            if (!PeerID.fromValue(contact.nodeId).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)
+                }
+                if (this.neighborList!.getContact(rpcRemote.getPeerId()) !== undefined) {
+                    this.neighborList!.addContact(rpcRemote)
+                }
+            }
+        })
+    }
+}

package/src/dht/contact/ContactList.ts

@@ -19,6 +19,7 @@ export interface Events<C> {
 export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
 
     protected contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
+    // TODO move this to SortedContactList
     protected contactIds: PeerID[] = []
     protected ownId: PeerID
     protected maxSize: number
@@ -35,8 +36,8 @@ export class ContactList<C extends { getPeerId: () => PeerID }> extends EventEmi
         this.defaultContactQueryLimit = defaultContactQueryLimit
     }
 
-    public getContact(id: PeerID): ContactState<C> {
-        return this.contactsById.get(id.toKey())!
+    public getContact(id: PeerID): ContactState<C> | undefined {
+        return this.contactsById.get(id.toKey())
     }
 
     public getSize(): number {

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

@@ -15,7 +15,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 +27,26 @@ const getRpcTimeout = (localPeerDescriptor: PeerDescriptor, remotePeerDescriptor
     return WEBRTC_TIMEOUT
 }
 
-export abstract class Remote<T> {
+export abstract class RpcRemote<T> {
 
     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
+        timeout?: number
     ) {
         this.localPeerDescriptor = localPeerDescriptor
         this.remotePeerDescriptor = remotePeerDescriptor
         this.client = client
         this.serviceId = serviceId
-        this.rpcTimeout = rpcTimeout
+        this.timeout = timeout
     }
 
     getPeerDescriptor(): PeerDescriptor {
@@ -68,7 +69,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/discovery/DiscoverySession.ts

@@ -1,15 +1,12 @@
-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 { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { ServiceID } from '../../types/ServiceID'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { PeerManager } from '../PeerManager'
 
 const logger = new Logger(module)
 
@@ -18,16 +15,11 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    bucket: KBucket<DhtNodeRpcRemote>
-    neighborList: SortedContactList<DhtNodeRpcRemote>
     targetId: Uint8Array
     localPeerDescriptor: PeerDescriptor
-    serviceId: ServiceID
-    rpcCommunicator: RpcCommunicator
     parallelism: number
     noProgressLimit: number
-    newContactListener?: (rpcRemote: DhtNodeRpcRemote) => void
-    rpcRequestTimeout?: number
+    peerManager: PeerManager
 }
 
 export class DiscoverySession {
@@ -48,23 +40,7 @@ export class DiscoverySession {
         if (this.stopped) {
             return
         }
-        contacts.forEach((contact) => {
-            if (!areEqualPeerDescriptors(contact, this.config.localPeerDescriptor)) {
-                const rpcRemote = new DhtNodeRpcRemote(
-                    this.config.localPeerDescriptor,
-                    contact,
-                    toProtoRpcClient(new DhtNodeRpcClient(this.config.rpcCommunicator.getRpcClientTransport())),
-                    this.config.serviceId,
-                    this.config.rpcRequestTimeout
-                )
-                if (this.config.newContactListener) {
-                    this.config.newContactListener(rpcRemote)
-                }
-                if (!this.config.neighborList.getContact(rpcRemote.getPeerId())) {
-                    this.config.neighborList.addContact(rpcRemote)
-                }
-            }
-        })
+        this.config.peerManager.handleNewPeers(contacts)
     }
 
     private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
@@ -73,9 +49,9 @@ export class DiscoverySession {
         }
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
-        this.config.neighborList.setContacted(contact.getPeerId())
+        this.config.peerManager.neighborList!.setContacted(contact.getPeerId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
-        this.config.neighborList.setActive(contact.getPeerId())
+        this.config.peerManager.handlePeerActive(contact.getPeerId())
         return returnedContacts
     }
 
@@ -84,9 +60,9 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peerId.toKey())
-        const oldClosestContact = this.config.neighborList.getClosestContactId()
+        const oldClosestContact = this.config.peerManager.neighborList!.getClosestContactId()
         this.addNewContacts(contacts)
-        if (this.config.neighborList.getClosestContactId().equals(oldClosestContact)) {
+        if (this.config.peerManager.neighborList!.getClosestContactId().equals(oldClosestContact)) {
             this.noProgressCounter++
         } else {
             this.noProgressCounter = 0
@@ -98,15 +74,14 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peer.getPeerId().toKey())
-        this.config.bucket.remove(peer.getPeerId().value)
-        this.config.neighborList.removeContact(peer.getPeerId())
+        this.config.peerManager.handlePeerUnresponsive(peer.getPeerId())
     }
 
     private findMoreContacts(): void {
         if (this.stopped) {
             return
         }
-        const uncontacted = this.config.neighborList.getUncontactedContacts(this.config.parallelism)
+        const uncontacted = this.config.peerManager.neighborList!.getUncontactedContacts(this.config.parallelism)
         if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
             this.emitter.emit('discoveryCompleted')
             this.stopped = true
@@ -129,17 +104,17 @@ export class DiscoverySession {
     }
 
     public async findClosestNodes(timeout: number): Promise<SortedContactList<DhtNodeRpcRemote>> {
-        if (this.config.neighborList.getUncontactedContacts(this.config.parallelism).length === 0) {
-            logger.trace('getUncontactedContacts length was 0 in beginning of discovery, this.neighborList.size: '
-                + this.config.neighborList.getSize())
-            return this.config.neighborList
+        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!
         }
         await runAndWaitForEvents3<DiscoverySessionEvents>(
             [this.findMoreContacts.bind(this)],
             [[this.emitter, 'discoveryCompleted']],
             timeout
         )
-        return this.config.neighborList
+        return this.config.peerManager.neighborList!
     }
 
     public stop(): void {

package/src/dht/discovery/PeerDiscovery.ts

@@ -3,26 +3,20 @@ import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
-import KBucket from 'k-bucket'
-import { SortedContactList } from '../contact/SortedContactList'
 import { ConnectionManager } from '../../connection/ConnectionManager'
-import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { createRandomKademliaId } from '../../helpers/kademliaId'
+import { createRandomNodeId } from '../../helpers/nodeId'
 import { ServiceID } from '../../types/ServiceID'
+import { PeerManager } from '../PeerManager'
 
 interface PeerDiscoveryConfig {
-    rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
-    bucket: KBucket<DhtNodeRpcRemote>
-    neighborList: SortedContactList<DhtNodeRpcRemote>
     joinNoProgressLimit: number
     peerDiscoveryQueryBatchSize: number
     serviceId: ServiceID
     parallelism: number
     joinTimeout: number
-    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     connectionManager?: ConnectionManager
-    rpcRequestTimeout?: number
+    peerManager: PeerManager
 }
 
 const logger = new Logger(module)
@@ -55,13 +49,13 @@ export class PeerDiscovery {
             return
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
-        this.config.addContact(entryPointDescriptor)
+        this.config.peerManager.handleNewPeers([entryPointDescriptor])
         const targetId = peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value
-        const closest = this.config.bucket.closest(targetId, this.config.peerDiscoveryQueryBatchSize)
-        this.config.neighborList.addContacts(closest)
+        const 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(createRandomKademliaId()))
+            sessions.push(this.createSession(createRandomNodeId()))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
         this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
@@ -70,15 +64,11 @@ export class PeerDiscovery {
 
     private createSession(targetId: Uint8Array): DiscoverySession {
         const sessionOptions = {
-            bucket: this.config.bucket,
-            neighborList: this.config.neighborList,
             targetId,
             localPeerDescriptor: this.config.localPeerDescriptor,
-            serviceId: this.config.serviceId,
-            rpcCommunicator: this.config.rpcCommunicator,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
-            newContactListener: (newPeer: DhtNodeRpcRemote) => this.config.addContact(newPeer.getPeerDescriptor())
+            peerManager: this.config.peerManager
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -93,8 +83,9 @@ export class PeerDiscovery {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
             if (!this.isStopped()) {
-                if (this.config.bucket.count() === 0) {
+                if (this.config.peerManager.bucket!.count() === 0) {
                     if (retry) {
+                        // TODO should we catch possible promise rejection?
                         setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
                     }
                 } else {
@@ -112,12 +103,13 @@ export class PeerDiscovery {
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
-            this.config.neighborList.clear()
+            this.config.peerManager.neighborList!.clear()
             await this.joinDht(entryPoint)
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
             if (!this.isStopped()) {
+                // TODO should we catch possible promise rejection?
                 setAbortableTimeout(() => this.rejoinDht(entryPoint), 5000, this.abortController.signal)
             }
         } finally {
@@ -136,11 +128,14 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
-        const nodes = this.config.bucket.closest(peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value, this.config.parallelism)
+        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.kademliaId)
+            const contacts = await peer.getClosestPeers(this.config.localPeerDescriptor.nodeId)
             contacts.forEach((contact) => {
-                this.config.addContact(contact)
+                this.config.peerManager.handleNewPeers([contact])
             })
         }))
     }