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

package/src/dht/discovery/DiscoverySession.ts

@@ -1,12 +1,11 @@
 import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
-import { PeerID } from '../../helpers/PeerID'
+import { PeerID, PeerIDKey } from '../../helpers/PeerID'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { SortedContactList } from '../contact/SortedContactList'
+import { PeerManager, getDistance } from '../PeerManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { PeerManager } from '../PeerManager'
 
 const logger = new Logger(module)
 
@@ -16,10 +15,11 @@ interface DiscoverySessionEvents {
 
 interface DiscoverySessionConfig {
     targetId: Uint8Array
-    localPeerDescriptor: PeerDescriptor
     parallelism: number
     noProgressLimit: number
     peerManager: PeerManager
+    // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
+    contactedPeers: Set<PeerIDKey>
 }
 
 export class DiscoverySession {
@@ -49,7 +49,7 @@ export class DiscoverySession {
         }
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.outgoingClosestPeersRequestsCounter++
-        this.config.peerManager.neighborList!.setContacted(contact.getPeerId())
+        this.config.contactedPeers.add(contact.getPeerId().toKey())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
         this.config.peerManager.handlePeerActive(contact.getPeerId())
         return returnedContacts
@@ -60,9 +60,12 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peerId.toKey())
-        const oldClosestContact = this.config.peerManager.neighborList!.getClosestContactId()
+        const oldClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const oldClosestDistance = getDistance(this.config.targetId, oldClosestNeighbor.getPeerId().value)
         this.addNewContacts(contacts)
-        if (this.config.peerManager.neighborList!.getClosestContactId().equals(oldClosestContact)) {
+        const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const newClosestDistance = getDistance(this.config.targetId, newClosestNeighbor.getPeerId().value)
+        if (newClosestDistance >= oldClosestDistance) {
             this.noProgressCounter++
         } else {
             this.noProgressCounter = 0
@@ -81,7 +84,7 @@ export class DiscoverySession {
         if (this.stopped) {
             return
         }
-        const uncontacted = this.config.peerManager.neighborList!.getUncontactedContacts(this.config.parallelism)
+        const uncontacted = this.config.peerManager.getClosestContactsTo(this.config.targetId, this.config.parallelism, this.config.contactedPeers)
         if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
             this.emitter.emit('discoveryCompleted')
             this.stopped = true
@@ -103,18 +106,16 @@ export class DiscoverySession {
         }
     }
 
-    public async findClosestNodes(timeout: number): Promise<SortedContactList<DhtNodeRpcRemote>> {
-        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!
+    public async findClosestNodes(timeout: number): Promise<void> {
+        if (this.config.peerManager.getNumberOfContacts(this.config.contactedPeers) === 0) {
+            return
         }
+        // TODO add abortController and signal it in stop()
         await runAndWaitForEvents3<DiscoverySessionEvents>(
             [this.findMoreContacts.bind(this)],
             [[this.emitter, 'discoveryCompleted']],
             timeout
         )
-        return this.config.peerManager.neighborList!
     }
 
     public stop(): void {

package/src/dht/discovery/PeerDiscovery.ts

@@ -4,9 +4,10 @@ import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDes
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
 import { ConnectionManager } from '../../connection/ConnectionManager'
+import { PeerManager } from '../PeerManager'
 import { createRandomNodeId } from '../../helpers/nodeId'
 import { ServiceID } from '../../types/ServiceID'
-import { PeerManager } from '../PeerManager'
+import { PeerIDKey } from '../../helpers/PeerID'
 
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
@@ -36,7 +37,27 @@ export class PeerDiscovery {
         this.abortController = new AbortController()
     }
 
-    async joinDht(entryPointDescriptor: PeerDescriptor, doAdditionalRandomPeerDiscovery = true, retry = true): Promise<void> {
+    async joinDht(
+        entryPoints: PeerDescriptor[],
+        doAdditionalRandomPeerDiscovery = true,
+        retry = true
+    ): Promise<void> {
+        const contactedPeers = new Set<PeerIDKey>()
+        await Promise.all(entryPoints.map((entryPoint) => this.joinThroughEntryPoint(
+            entryPoint,
+            contactedPeers,
+            doAdditionalRandomPeerDiscovery,
+            retry
+        )))
+    }
+
+    async joinThroughEntryPoint(
+        entryPointDescriptor: PeerDescriptor,
+        // Note that this set is mutated by DiscoverySession
+        contactedPeers: Set<PeerIDKey>,
+        doAdditionalRandomPeerDiscovery = true,
+        retry = true
+    ): Promise<void> {
         if (this.isStopped()) {
             return
         }
@@ -51,24 +72,22 @@ export class PeerDiscovery {
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
         this.config.peerManager.handleNewPeers([entryPointDescriptor])
         const targetId = peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value
-        const closest = this.config.peerManager.bucket!.closest(targetId, this.config.peerDiscoveryQueryBatchSize)
-        this.config.peerManager.neighborList!.addContacts(closest)
-        const sessions = [this.createSession(targetId)]
+        const sessions = [this.createSession(targetId, contactedPeers)]
         if (doAdditionalRandomPeerDiscovery) {
-            sessions.push(this.createSession(createRandomNodeId()))
+            sessions.push(this.createSession(createRandomNodeId(), contactedPeers))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
         this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
 
     }
 
-    private createSession(targetId: Uint8Array): DiscoverySession {
+    private createSession(targetId: Uint8Array, contactedPeers: Set<PeerIDKey>): DiscoverySession {
         const sessionOptions = {
             targetId,
-            localPeerDescriptor: this.config.localPeerDescriptor,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
-            peerManager: this.config.peerManager
+            peerManager: this.config.peerManager,
+            contactedPeers
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -83,7 +102,7 @@ export class PeerDiscovery {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
             if (!this.isStopped()) {
-                if (this.config.peerManager.bucket!.count() === 0) {
+                if (this.config.peerManager.getNumberOfNeighbors() === 0) {
                     if (retry) {
                         // TODO should we catch possible promise rejection?
                         setAbortableTimeout(() => this.rejoinDht(entryPointDescriptor), 1000, this.abortController.signal)
@@ -103,8 +122,7 @@ export class PeerDiscovery {
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
-            this.config.peerManager.neighborList!.clear()
-            await this.joinDht(entryPoint)
+            await this.joinThroughEntryPoint(entryPoint, new Set())
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
@@ -128,16 +146,13 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
-        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.nodeId)
-            contacts.forEach((contact) => {
-                this.config.peerManager.handleNewPeers([contact])
+        const nodes = this.config.peerManager.getClosestNeighborsTo(this.config.localPeerDescriptor.nodeId, this.config.parallelism)
+        await Promise.allSettled(
+            nodes.map(async (peer: DhtNodeRpcRemote) => {
+                const contacts = await peer.getClosestPeers(this.config.localPeerDescriptor.nodeId!)
+                this.config.peerManager.handleNewPeers(contacts)    
             })
-        }))
+        )
     }
 
     public isJoinOngoing(): boolean {
@@ -158,7 +173,7 @@ export class PeerDiscovery {
             clearTimeout(this.rejoinTimeoutRef)
             this.rejoinTimeoutRef = undefined
         }
-        this.ongoingDiscoverySessions.forEach((session, _id) => {
+        this.ongoingDiscoverySessions.forEach((session) => {
             session.stop()
         })
     }

package/src/dht/find/FindSession.ts

@@ -46,7 +46,12 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
         this.nodeIdToFind = config.nodeIdToFind
         this.localPeerId = config.localPeerId
         this.waitedRoutingPathCompletions = config.waitedRoutingPathCompletions
-        this.results = new SortedContactList(PeerID.fromValue(this.nodeIdToFind), 10, undefined, true)
+        this.results = new SortedContactList({
+            referenceId: PeerID.fromValue(this.nodeIdToFind), 
+            maxSize: 10,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
         this.action = config.action
         this.rpcCommunicator = new ListeningRpcCommunicator(this.serviceId, this.transport, {
             rpcRequestTimeout: 15000

package/src/dht/find/Finder.ts

@@ -275,13 +275,12 @@ export class Finder implements IFinder {
 
     private getClosestConnections(nodeId: Uint8Array, limit: number): PeerDescriptor[] {
         const connectedPeers = Array.from(this.connections.values())
-        const closestPeers = new SortedContactList<DhtNodeRpcRemote>(
-            PeerID.fromValue(nodeId),
-            limit,
-            undefined,
-            true,
-            undefined
-        )
+        const closestPeers = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: PeerID.fromValue(nodeId),
+            maxSize: limit,
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
         closestPeers.addContacts(connectedPeers)
         return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
     }

package/src/dht/routing/Router.ts

@@ -134,13 +134,13 @@ export class Router implements IRouter {
         }
     }
 
-    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE): RouteMessageAck {
+    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: PeerDescriptor): RouteMessageAck {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
         logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
             + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`)
-        const session = this.createRoutingSession(routedMessage, mode)
+        const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
         const contacts = session.updateAndGetRoutablePeers()
         if (contacts.length > 0) {
             this.addRoutingSession(session)
@@ -173,7 +173,11 @@ export class Router implements IRouter {
         }
     }
 
-    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode): RoutingSession {
+    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RoutingSession {
+        const excludedPeers = routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
+        if (excludedPeer) {
+            excludedPeers.push(peerIdFromPeerDescriptor(excludedPeer))
+        }
         logger.trace('routing session created with connections: ' + this.connections.size)
         return new RoutingSession(
             this.rpcCommunicator,
@@ -182,7 +186,7 @@ export class Router implements IRouter {
             this.connections,
             areEqualPeerDescriptors(this.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
-            routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
+            excludedPeers
         )
     }
 

package/src/dht/routing/RoutingSession.ts

@@ -98,14 +98,14 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         this.mode = mode
         const previousPeer = getPreviousPeer(messageToRoute)
         const previousId = previousPeer ? PeerID.fromValue(previousPeer.nodeId) : undefined
-        this.contactList = new SortedContactList(
-            PeerID.fromValue(this.messageToRoute.destinationPeer!.nodeId),
-            10000,
-            undefined,
-            true,
-            previousId,
-            excludedPeerIDs
-        )
+        this.contactList = new SortedContactList({
+            referenceId: PeerID.fromValue(this.messageToRoute.destinationPeer!.nodeId),
+            maxSize: 10000,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            peerIdDistanceLimit: previousId,
+            excludedPeerIDs: excludedPeerIDs,
+            emitEvents: false
+        })
     }
 
     private onRequestFailed(peerId: PeerID) {

package/src/dht/store/StoreRpcLocal.ts

@@ -93,8 +93,12 @@ export class StoreRpcLocal implements IStoreRpc {
         const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
 
         const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.key, 10)
-
-        const sortedList = new SortedContactList<Contact>(dataId, 20, undefined, true)
+        const sortedList = new SortedContactList<Contact>({
+            referenceId: PeerID.fromValue(dataEntry.key), 
+            maxSize: 20,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
         sortedList.addContact(new Contact(this.localPeerDescriptor))
 
         closestToData.forEach((con) => {
@@ -108,6 +112,7 @@ export class StoreRpcLocal implements IStoreRpc {
             return false
         }
 
+        this.localDataStore.setStale(dataId, dataEntry.creator!, false)
         const newPeerId = PeerID.fromValue(newNode.nodeId)
         sortedList.addContact(new Contact(newNode))
 
@@ -125,10 +130,8 @@ export class StoreRpcLocal implements IStoreRpc {
         // do replicate data to it
 
         if (index < this.redundancyFactor) {
-            this.localDataStore.setStale(dataId, dataEntry.creator!, false)
             return true
         } else {
-            this.localDataStore.setStale(dataId, dataEntry.creator!, true)
             return false
         }
     }
@@ -201,7 +204,12 @@ export class StoreRpcLocal implements IStoreRpc {
     private selfIsOneOfClosestPeers(dataId: Uint8Array): boolean {
         const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
         const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.redundancyFactor)
-        const sortedList = new SortedContactList<Contact>(localPeerId, this.redundancyFactor, undefined, true)
+        const sortedList = new SortedContactList<Contact>({
+            referenceId: localPeerId, 
+            maxSize: this.redundancyFactor, 
+            allowToContainReferenceId: true, 
+            emitEvents: false
+        })
         sortedList.addContact(new Contact(this.localPeerDescriptor))
         closestPeers.forEach((con) => sortedList.addContact(new Contact(con.getPeerDescriptor())))
         return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(localPeerId))
@@ -282,8 +290,12 @@ export class StoreRpcLocal implements IStoreRpc {
         const dataId = PeerID.fromValue(dataEntry.key)
         const incomingPeerId = PeerID.fromValue(incomingPeer.nodeId)
         const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.key, 10)
-
-        const sortedList = new SortedContactList<Contact>(dataId, this.redundancyFactor, undefined, true)
+        const sortedList = new SortedContactList<Contact>({
+            referenceId: dataId, 
+            maxSize: this.redundancyFactor, 
+            allowToContainReferenceId: true, 
+            emitEvents: false
+        })
         sortedList.addContact(new Contact(this.localPeerDescriptor))
 
         closestToData.forEach((con) => {

package/src/helpers/PeerID.ts

@@ -1,10 +1,14 @@
-import { BrandedString } from '@streamr/utils'
+import { BrandedString, binaryToHex } from '@streamr/utils'
 import { UUID } from './UUID'
 import { IllegalArguments } from './errors'
 import crypto from 'crypto'
 
 export type PeerIDKey = BrandedString<'PeerIDKey'>
 
+export const createPeerIDKey = (nodeId: Uint8Array): PeerIDKey => {
+    return binaryToHex(nodeId) as PeerIDKey
+}
+
 export class PeerID {
     // avoid creating a new instance for every operation
     private static readonly textEncoder = new TextEncoder() 
@@ -30,7 +34,7 @@ export class PeerID {
             throw new IllegalArguments('Constructor of PeerID must be given either ip, value or stringValue')
         }
 
-        this.key = Buffer.from(this.data).toString('hex') as PeerIDKey
+        this.key = createPeerIDKey(this.data)
     }
 
     static fromIp(ip: string): PeerID {

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -1,6 +1,6 @@
-import { binaryToHex } from '@streamr/utils'
+import { areEqualBinaries, binaryToHex } from '@streamr/utils'
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
-import { PeerID, PeerIDKey } from './PeerID'
+import { PeerID, PeerIDKey, createPeerIDKey } from './PeerID'
 
 export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID => {
     return PeerID.fromValue(peerDescriptor.nodeId)
@@ -12,9 +12,9 @@ export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): str
 }
 
 export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey => {
-    return PeerID.fromValue(peerDescriptor.nodeId).toKey()
+    return createPeerIDKey(peerDescriptor.nodeId)
 }
 
 export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
-    return peerIdFromPeerDescriptor(peerDescriptor1).equals(peerIdFromPeerDescriptor(peerDescriptor2))
+    return areEqualBinaries(peerDescriptor1.nodeId, peerDescriptor2.nodeId)
 }

package/test/benchmark/Find.test.ts

@@ -71,7 +71,7 @@ describe('Find correctness', () => {
         logger.info('waiting over')
 
         nodes.forEach((node) => logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ': connections:' +
-            node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
+            node.getNumberOfConnections() + ', kbucket: ' + node.getNumberOfNeighbors()
             + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
             + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()
             + ', weakLocked: ' + node.getNumberOfWeakLockedConnections()))

package/test/benchmark/KademliaCorrectness.test.ts

@@ -102,7 +102,7 @@ describe('Kademlia correctness', () => {
             }
 
             if (i > 0) {
-                sumKbucketSize += nodes[i].getBucketSize()
+                sumKbucketSize += nodes[i].getNumberOfNeighbors()
                 sumCorrectNeighbors += correctNeighbors
             }
         }

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -0,0 +1,150 @@
+/* eslint-disable no-console */
+
+import KBucket from 'k-bucket'
+import { SortedContactList } from '../../src/dht/contact/SortedContactList'
+import { PeerID } from '../../src/helpers/PeerID'
+import crypto from 'crypto'
+
+const NUM_ADDS = 1000
+interface Item {
+    id: Uint8Array
+    vectorClock: number
+    getPeerId: () => PeerID
+}
+
+const createRandomItem = (index: number): Item => {
+    const rand = new Uint8Array(crypto.randomBytes(20))
+    return {
+        getPeerId: () => PeerID.fromValue(rand),
+        id: rand,
+        vectorClock: index
+    }
+}
+
+function shuffleArray<T>(array: T[]): T[] {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]]
+    }
+    return array
+}
+
+describe('SortedContactListBenchmark', () => {
+
+    it('adds ' + NUM_ADDS + ' random peerIDs', async () => {
+        const randomIds = []
+        for (let i = 0; i < NUM_ADDS; i++) {
+            randomIds.push(createRandomItem(i))
+        }
+        const list = new SortedContactList({
+            referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+            allowToContainReferenceId: true,
+            emitEvents: true
+        })
+
+        console.time('SortedContactList.addContact() with emitEvents=true')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            list.addContact(randomIds[i])
+        }
+        console.timeEnd('SortedContactList.addContact() with emitEvents=true')
+
+        const list2 = new SortedContactList({
+            referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
+
+        console.time('SortedContactList.addContact() with emitEvents=false')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            list2.addContact(randomIds[i])
+        }
+        console.timeEnd('SortedContactList.addContact() with emitEvents=false')
+
+        const kBucket = new KBucket<Item>({ localNodeId: crypto.randomBytes(20) })
+        console.time('KBucket.add()')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            kBucket.add(randomIds[i])
+        }
+        console.timeEnd('KBucket.add()')
+
+        console.time('kBucket toArray()')
+
+        for (let i = 0; i < NUM_ADDS; i++) {
+            kBucket.toArray()
+        }
+        console.timeEnd('kBucket toArray()')
+
+        console.time('kBucket closest()')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            kBucket.closest(crypto.randomBytes(20), 20)
+        }
+        console.timeEnd('kBucket closest()')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=true')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+                allowToContainReferenceId: true,
+                emitEvents: true
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            arrayFromBucket.map((contact) => closest.addContact(contact))
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=true')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=false')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+                allowToContainReferenceId: true,
+                emitEvents: false
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            arrayFromBucket.map((contact) => closest.addContact(contact))
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+                allowToContainReferenceId: true,
+                emitEvents: false
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            arrayFromBucket.map((contact) => closest.addContact(contact))
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
+
+        console.time('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const closest = new SortedContactList<Item>({
+                referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+                allowToContainReferenceId: true,
+                emitEvents: false
+            })
+
+            const arrayFromBucket = kBucket.toArray()
+            closest.addContacts(arrayFromBucket)
+            closest.getClosestContacts(20)
+        }
+        console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
+
+        const shuffled = shuffleArray(kBucket.toArray())
+        console.time('kbucket add and closest')
+        for (let i = 0; i < NUM_ADDS; i++) {
+            const bucket2 = new KBucket<Item>({ localNodeId: crypto.randomBytes(20) })
+
+            shuffled.map((contact) => bucket2.add(contact))
+            bucket2.closest(crypto.randomBytes(20), 20)
+        }
+        console.timeEnd('kbucket add and closest')
+
+    })
+})

package/test/benchmark/WebsocketServerMemoryLeak.test.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+
+import { wait } from '@streamr/utils'
+import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
+import { ClientWebsocket } from '../../src/exports'
+
+// This 'test' is meant to be run manually using the following command:
+// node --inspect ../../../../node_modules/.bin/jest WebsocketServerMemoryLeak.test.ts
+// while wathing for memory leaks in Chrome DevTools
+
+describe('WebsocketServermemoryLeak', () => {
+
+    it('Accepts and detroys connections', async () => {
+        const server = new WebsocketServer({
+            portRange: { min: 19792, max: 19792 },
+            enableTls: false
+        })
+
+        server.on('connected', (connection) => {
+            console.log('ServerWebsocket connected')
+            connection.destroy()
+            console.log('ServerWebsocket destroyed')
+        })
+
+        const port = await server.start()
+        expect(port).toEqual(19792)
+        
+        for (let i = 0; i < 10000; i++) {
+            const clientWebsocket: ClientWebsocket = new ClientWebsocket()
+            clientWebsocket.on('connected', () => {
+                console.log('clientWebsocket connected ' + i)
+            })
+            
+            clientWebsocket.connect(`ws://127.0.0.1:${port}`)
+            i++
+            await wait(3000)
+        }
+
+        await server.stop()
+    }, 120000000)
+})

package/test/benchmark/kademlia-simulation/SimulationNode.ts

@@ -26,7 +26,12 @@ export class SimulationNode {
             numberOfNodesPerKBucket: this.numberOfNodesPerKBucket
         })
 
-        this.neighborList = new SortedContactList(this.ownId, 1000)
+        this.neighborList = new SortedContactList({ 
+            referenceId: this.ownId, 
+            maxSize: 1000,
+            allowToContainReferenceId: false,
+            emitEvents: false
+        })
     }
 
     // For simulation use

package/test/end-to-end/Layer0.test.ts

@@ -71,9 +71,9 @@ describe('Layer0', () => {
             node4.joinDht([epPeerDescriptor])
         ])
 
-        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
     }, 10000)
 })