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

package/src/dht/DhtNode.ts

@@ -51,7 +51,7 @@ import { MarkRequired } from 'ts-essentials'
 import { DhtNodeRpcLocal } from './DhtNodeRpcLocal'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { ExternalApiRpcLocal } from './ExternalApiRpcLocal'
-import { PeerManager } from './PeerManager'
+import { PeerManager, getDistance } from './PeerManager'
 
 export interface DhtNodeEvents {
     newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
@@ -148,7 +148,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
 
     public connectionManager?: ConnectionManager
     private started = false
-    private stopped = false
+    private abortController = new AbortController()
     private entryPointDisconnectTimeout?: NodeJS.Timeout
 
     constructor(conf: DhtNodeOptions) {
@@ -173,7 +173,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async start(): Promise<void> {
-        if (this.started || this.stopped) {
+        if (this.started || this.abortController.signal.aborted) {
             return
         }
         logger.trace(`Starting new Streamr Network DHT Node with serviceId ${this.config.serviceId}`)
@@ -283,7 +283,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             localDataStore: this.localDataStore,
             dhtNodeEmitter: this,
             getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => {
-                return this.peerManager!.bucket!.closest(id, n)
+                return this.peerManager!.getClosestNeighborsTo(id, n)
             },
             rpcRequestTimeout: this.config.rpcRequestTimeout
         })
@@ -297,7 +297,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     private initPeerManager() {
         this.peerManager = new PeerManager({
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
-            maxNeighborListSize: this.config.maxNeighborListSize,
+            maxContactListSize: this.config.maxNeighborListSize,
             ownPeerId: this.getNodeId(),
             connectionManager: this.connectionManager!,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
@@ -343,13 +343,16 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private bindRpcLocalMethods(): void {
-        if (!this.started || this.stopped) {
+        if (!this.started || this.abortController.signal.aborted) {
             return
         }
         const dhtNodeRpcLocal = new DhtNodeRpcLocal({
-            bucket: this.peerManager!.bucket!,
             serviceId: this.config.serviceId,
             peerDiscoveryQueryBatchSize: this.config.peerDiscoveryQueryBatchSize,
+            getClosestPeersTo: (kademliaId: Uint8Array, limit: number) => {
+                return this.peerManager!.getClosestNeighborsTo(kademliaId, limit)
+                    .map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
+            },
             addNewContact: (contact: PeerDescriptor) => this.peerManager!.handleNewPeers([contact]),
             removeContact: (contact: PeerDescriptor) => this.removeContact(contact)
         })
@@ -382,8 +385,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     private isPeerCloserToIdThanSelf(peer1: PeerDescriptor, compareToId: PeerID): boolean {
-        const distance1 = this.peerManager!.bucket!.distance(peer1.nodeId, compareToId.value)
-        const distance2 = this.peerManager!.bucket!.distance(this.localPeerDescriptor!.nodeId, compareToId.value)
+        const distance1 = getDistance(peer1.nodeId, compareToId.value)
+        const distance2 = getDistance(this.localPeerDescriptor!.nodeId, compareToId.value)
         return distance1 < distance2
     }
 
@@ -408,16 +411,16 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return this.localPeerDescriptor
     }
 
-    public getClosestContacts(maxCount?: number): PeerDescriptor[] {
-        return this.peerManager!.neighborList!.getClosestContacts(maxCount).map((c) => c.getPeerDescriptor())
+    public getClosestContacts(limit?: number): PeerDescriptor[] {
+        return this.peerManager!.getClosestContactsTo(this.localPeerDescriptor!.nodeId, limit).map((peer) => peer.getPeerDescriptor())
     }
-
+    
     public getNodeId(): PeerID {
         return peerIdFromPeerDescriptor(this.localPeerDescriptor!)
     }
 
-    public getBucketSize(): number {
-        return this.peerManager!.bucket!.count()
+    public getNumberOfNeighbors(): number {
+        return this.peerManager!.getNumberOfNeighbors()
     }
 
     private connectToEntryPoint(entryPoint: PeerDescriptor): void {
@@ -435,7 +438,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async send(msg: Message): Promise<void> {
-        if (!this.started || this.stopped) {
+        if (!this.started || this.abortController.signal.aborted) {
             return
         }
         const reachableThrough = this.peerDiscovery!.isJoinOngoing() ? this.config.entryPoints ?? [] : []
@@ -446,9 +449,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (!this.started) {
             throw new Error('Cannot join DHT before calling start() on DhtNode')
         }
-        await Promise.all(entryPointDescriptors.map((entryPoint) =>
-            this.peerDiscovery!.joinDht(entryPoint, doAdditionalRandomPeerDiscovery, retry)
-        ))
+        await this.peerDiscovery!.joinDht(entryPointDescriptors, doAdditionalRandomPeerDiscovery, retry)
     }
 
     public async startFind(key: Uint8Array, action?: FindAction, excludedPeer?: PeerDescriptor): Promise<FindResult> {
@@ -481,7 +482,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async deleteDataFromDht(key: Uint8Array, waitForCompletion: boolean): Promise<void> {
-        if (!this.stopped) {
+        if (!this.abortController.signal.aborted) {
             await this.finder!.startFind(key, FindAction.DELETE_DATA, undefined, waitForCompletion)
         }
     }
@@ -508,8 +509,9 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         return Array.from(this.peerManager!.connections.values()).map((peer) => peer.getPeerDescriptor())
     }
 
-    public getKBucketPeers(): PeerDescriptor[] {
-        return this.peerManager!.bucket!.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
+    // TODO rename to getNeighbors
+    public getAllNeighborPeerDescriptors(): PeerDescriptor[] {
+        return this.peerManager!.getNeighbors()
     }
 
     public getNumberOfConnections(): number {
@@ -529,7 +531,13 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async waitForNetworkConnectivity(): Promise<void> {
-        await waitForCondition(() => this.peerManager!.connections.size > 0, this.config.networkConnectivityTimeout)
+        await waitForCondition(() => {
+            if (!this.peerManager) {
+                return false
+            } else {
+                return (this.peerManager.getNumberOfConnections() > 0)
+            }
+        }, this.config.networkConnectivityTimeout, 100, this.abortController.signal)
     }
 
     public hasJoined(): boolean {
@@ -537,11 +545,11 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
     }
 
     public async stop(): Promise<void> {
-        if (this.stopped || !this.started) {
+        if (this.abortController.signal.aborted || !this.started) {
             return
         }
         logger.trace('stop()')
-        this.stopped = true
+        this.abortController.abort()
         await this.storeRpcLocal!.destroy()
         if (this.entryPointDisconnectTimeout) {
             clearTimeout(this.entryPointDisconnectTimeout)

package/src/dht/DhtNodeRpcLocal.ts

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

package/src/dht/PeerManager.ts

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

package/src/dht/contact/SortedContactList.ts

@@ -1,26 +1,34 @@
-import KBucket from 'k-bucket'
-import { PeerID } from '../../helpers/PeerID'
-import { ContactList, ContactState } from './ContactList'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
+import { ContactState, Events } from './ContactList'
+import { sortedIndexBy } from 'lodash'
+import EventEmitter from 'eventemitter3'
+import { getDistance } from '../PeerManager'
+
+export interface SortedContactListConfig {
+    referenceId: PeerID  // all contacts in this list are in sorted by the distance to this ID
+    allowToContainReferenceId: boolean
+    // TODO could maybe optimize this by removing the flag and then we'd check whether we have 
+    // any listeners before we emit the event
+    emitEvents: boolean
+    maxSize?: number
+    // if set, the list can't contain any contacts which are futher away than this limit
+    peerIdDistanceLimit?: PeerID
+    // if set, the list can't contain contacts with these ids
+    excludedPeerIDs?: PeerID[]
+}
 
-export class SortedContactList<C extends { getPeerId: () => PeerID }> extends ContactList<C> {
+export class SortedContactList<C extends { getPeerId: () => PeerID }> extends EventEmitter<Events<C>> {
 
-    private allowLocalPeerId: boolean
-    private peerIdDistanceLimit?: PeerID
-    private excludedPeerIDs?: PeerID[]
+    private config: SortedContactListConfig
+    private contactsById: Map<PeerIDKey, ContactState<C>> = new Map()
+    private contactIds: PeerID[] = []
 
     constructor(
-        ownId: PeerID,
-        maxSize: number,
-        defaultContactQueryLimit?: number,
-        allowLocalPeerId = false,
-        peerIdDistanceLimit?: PeerID,
-        excludedPeerIDs?: PeerID[]
+        config: SortedContactListConfig
     ) {
-        super(ownId, maxSize, defaultContactQueryLimit)
+        super()
+        this.config = config
         this.compareIds = this.compareIds.bind(this)
-        this.allowLocalPeerId = allowLocalPeerId
-        this.peerIdDistanceLimit = peerIdDistanceLimit
-        this.excludedPeerIDs = excludedPeerIDs
     }
 
     public getClosestContactId(): PeerID {
@@ -32,38 +40,44 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     }
 
     public addContact(contact: C): void {
-        if (this.excludedPeerIDs
-            && this.excludedPeerIDs.some((peerId) => contact.getPeerId().equals(peerId))) {
+        if (this.config.excludedPeerIDs !== undefined
+            && this.config.excludedPeerIDs.some((peerId) => contact.getPeerId().equals(peerId))) {
             return
         }
-        
-        if ((!this.allowLocalPeerId && this.ownId.equals(contact.getPeerId())) ||
-            (this.peerIdDistanceLimit !== undefined && this.compareIds(this.peerIdDistanceLimit, contact.getPeerId()) < 0)) {
+
+        if ((!this.config.allowToContainReferenceId && this.config.referenceId.equals(contact.getPeerId())) ||
+            (this.config.peerIdDistanceLimit !== undefined && this.compareIds(this.config.peerIdDistanceLimit, contact.getPeerId()) < 0)) {
             return
         }
         if (!this.contactsById.has(contact.getPeerId().toKey())) {
-            if (this.contactIds.length < this.maxSize) {
+            if ((this.config.maxSize === undefined) || (this.contactIds.length < this.config.maxSize)) {
                 this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
-                this.contactIds.push(contact.getPeerId())
-                this.contactIds.sort(this.compareIds)
-            } else if (this.compareIds(this.contactIds[this.maxSize - 1], contact.getPeerId()) > 0) {
+
+                const index = sortedIndexBy(this.contactIds, contact.getPeerId(), (id: PeerID) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contact.getPeerId())
+            } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contact.getPeerId()) > 0) {
                 const removedId = this.contactIds.pop()
                 const removedContact = this.contactsById.get(removedId!.toKey())!.contact
                 this.contactsById.delete(removedId!.toKey())
                 this.contactsById.set(contact.getPeerId().toKey(), new ContactState(contact))
-                this.contactIds.push(contact.getPeerId())
-                this.contactIds.sort(this.compareIds)
+
+                const index = sortedIndexBy(this.contactIds, contact.getPeerId(), (id: PeerID) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contact.getPeerId())
+                if (this.config.emitEvents) {
+                    this.emit(
+                        'contactRemoved',
+                        removedContact,
+                        this.getClosestContacts()
+                    )
+                }
+            }
+            if (this.config.emitEvents) {
                 this.emit(
-                    'contactRemoved',
-                    removedContact,
+                    'newContact',
+                    contact,
                     this.getClosestContacts()
                 )
             }
-            this.emit(
-                'newContact',
-                contact,
-                this.getClosestContacts()
-            )
         }
     }
 
@@ -71,6 +85,10 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         contacts.forEach((contact) => this.addContact(contact))
     }
 
+    public getContact(id: PeerID): ContactState<C> | undefined {
+        return this.contactsById.get(id.toKey())
+    }
+
     public setContacted(contactId: PeerID): void {
         if (this.contactsById.has(contactId.toKey())) {
             this.contactsById.get(contactId.toKey())!.contacted = true
@@ -83,7 +101,7 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
         }
     }
 
-    public getClosestContacts(limit = this.defaultContactQueryLimit): C[] {
+    public getClosestContacts(limit?: number): C[] {
         const ret: C[] = []
         this.contactIds.forEach((contactId) => {
             const contact = this.contactsById.get(contactId.toKey())
@@ -91,7 +109,11 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
                 ret.push(contact.contact)
             }
         })
-        return ret.slice(0, limit)
+        if (limit === undefined) {
+            return ret
+        } else {
+            return ret.slice(0, limit)
+        }
     }
 
     public getUncontactedContacts(num: number): C[] {
@@ -124,22 +146,29 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     }
 
     public compareIds(id1: PeerID, id2: PeerID): number {
-        const distance1 = KBucket.distance(this.ownId.value, id1.value)
-        const distance2 = KBucket.distance(this.ownId.value, id2.value)
+        const distance1 = this.distanceToReferenceId(id1)
+        const distance2 = this.distanceToReferenceId(id2)
         return distance1 - distance2
     }
 
+    // TODO inline this method?
+    private distanceToReferenceId(id: PeerID): number {
+        return getDistance(this.config.referenceId.value, id.value)
+    }
+
     public removeContact(id: PeerID): boolean {
         if (this.contactsById.has(id.toKey())) {
             const removed = this.contactsById.get(id.toKey())!.contact
             const index = this.contactIds.findIndex((element) => element.equals(id))
             this.contactIds.splice(index, 1)
             this.contactsById.delete(id.toKey())
-            this.emit(
-                'contactRemoved',
-                removed,
-                this.getClosestContacts()
-            )
+            if (this.config.emitEvents) {
+                this.emit(
+                    'contactRemoved',
+                    removed,
+                    this.getClosestContacts()
+                )
+            }
             return true
         }
         return false
@@ -152,4 +181,18 @@ export class SortedContactList<C extends { getPeerId: () => PeerID }> extends Co
     public getAllContacts(): C[] {
         return this.contactIds.map((peerId) => this.contactsById.get(peerId.toKey())!.contact)
     }
+
+    public getSize(): number {
+        return this.contactIds.length
+    }
+
+    public clear(): void {
+        this.contactsById.clear()
+        this.contactIds = []
+    }
+
+    public stop(): void {
+        this.removeAllListeners()
+        this.clear()
+    }
 }