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

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)
 })

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

@@ -89,11 +89,11 @@ describe('Layer0MixedConnectionTypes', () => {
             node5.joinDht([epPeerDescriptor])
         ])
 
-        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node5.getBucketSize()).toBeGreaterThanOrEqual(1)
+        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNumberOfNeighbors()).toBeGreaterThanOrEqual(1)
 
     }, 15000)
 
@@ -105,10 +105,10 @@ describe('Layer0MixedConnectionTypes', () => {
             node4.joinDht([epPeerDescriptor]),
             node5.joinDht([epPeerDescriptor])
         ])
-        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node5.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
     }, 30000)
 })

package/test/end-to-end/Layer0Webrtc-Layer1.test.ts

@@ -125,9 +125,9 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([entrypointDescriptor])
         await layer1Node4.joinDht([entrypointDescriptor])
 
-        expect(layer1Node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
     }, 60000)
 })

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -75,10 +75,10 @@ describe('Layer1 Scale', () => {
     // TODO: fix flaky test in NET-1021
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node ) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

package/test/end-to-end/Layer1-Scale-Webrtc.test.ts

@@ -65,10 +65,10 @@ describe('Layer1 Scale', () => {
 
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -46,7 +46,7 @@ describe('Failed autocertification', () => {
         const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
         expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
         await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
-        expect(failedAutocertificationNode.getBucketSize()).toEqual(2)
+        expect(failedAutocertificationNode.getNumberOfNeighbors()).toEqual(2)
     })
 
 })

package/test/end-to-end/memory-leak.test.ts

@@ -68,6 +68,7 @@ describe('memory leak', () => {
 
         const detector1 = new LeakDetector(entryPoint)
         entryPoint = undefined
+        await detector1.isLeaking()
         expect(await detector1.isLeaking()).toBe(false)
 
         const detector2 = new LeakDetector(sender)

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -25,10 +25,10 @@ const runTest = async (latencyType: LatencyType) => {
     await entryPoint.joinDht([entrypointDescriptor])
     await Promise.all(nodes.map((node) => node.joinDht([entrypointDescriptor])))
     nodes.forEach((node) => {
-        expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+        expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         expect(node.getClosestContacts().length).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
     })
-    expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+    expect(entryPoint.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
 
     await Promise.all([
         entryPoint.stop(),

package/test/integration/Layer1-scale.test.ts

@@ -75,7 +75,7 @@ describe('Layer1', () => {
             const layer1Node = layer1Nodes[i]
             expect(layer1Node.getNodeId().equals(layer0Node.getNodeId())).toEqual(true)
             expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
-            expect(layer1Node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(layer1Node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
             expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
         }
     }, 120000)

package/test/integration/Mock-Layer1-Layer0.test.ts

@@ -85,21 +85,21 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([entryPointDescriptor])
         await layer1Node4.joinDht([entryPointDescriptor])
 
-        logger.info('layer1EntryPoint.getBucketSize() ' + layer1EntryPoint.getBucketSize())
-        logger.info('layer1Node1.getBucketSize()' + layer1Node1.getBucketSize())
-        logger.info('layer1Node2.getBucketSize()' + layer1Node2.getBucketSize())
-        logger.info('layer1Node3.getBucketSize()' + layer1Node3.getBucketSize())
-        logger.info('layer1Node4.getBucketSize()' + layer1Node4.getBucketSize())
-
-        expect(layer1Node1.getBucketSize()).toEqual(layer0Node1.getBucketSize())
-        expect(layer1Node2.getBucketSize()).toEqual(layer0Node2.getBucketSize())
-        expect(layer1Node3.getBucketSize()).toEqual(layer0Node3.getBucketSize())
-        expect(layer1Node4.getBucketSize()).toEqual(layer0Node4.getBucketSize())
-
-        expect(layer1Node1.getKBucketPeers()).toContainValues(layer0Node1.getKBucketPeers())
-        expect(layer1Node2.getKBucketPeers()).toContainValues(layer0Node2.getKBucketPeers())
-        expect(layer1Node3.getKBucketPeers()).toContainValues(layer0Node3.getKBucketPeers())
-        expect(layer1Node4.getKBucketPeers()).toContainValues(layer0Node4.getKBucketPeers())
+        logger.info('layer1EntryPoint.getNumberOfNeighbors() ' + layer1EntryPoint.getNumberOfNeighbors())
+        logger.info('layer1Node1.getNumberOfNeighbors()' + layer1Node1.getNumberOfNeighbors())
+        logger.info('layer1Node2.getNumberOfNeighbors()' + layer1Node2.getNumberOfNeighbors())
+        logger.info('layer1Node3.getNumberOfNeighbors()' + layer1Node3.getNumberOfNeighbors())
+        logger.info('layer1Node4.getNumberOfNeighbors()' + layer1Node4.getNumberOfNeighbors())
+
+        expect(layer1Node1.getNumberOfNeighbors()).toEqual(layer0Node1.getNumberOfNeighbors())
+        expect(layer1Node2.getNumberOfNeighbors()).toEqual(layer0Node2.getNumberOfNeighbors())
+        expect(layer1Node3.getNumberOfNeighbors()).toEqual(layer0Node3.getNumberOfNeighbors())
+        expect(layer1Node4.getNumberOfNeighbors()).toEqual(layer0Node4.getNumberOfNeighbors())
+
+        expect(layer1Node1.getAllNeighborPeerDescriptors()).toContainValues(layer0Node1.getAllNeighborPeerDescriptors())
+        expect(layer1Node2.getAllNeighborPeerDescriptors()).toContainValues(layer0Node2.getAllNeighborPeerDescriptors())
+        expect(layer1Node3.getAllNeighborPeerDescriptors()).toContainValues(layer0Node3.getAllNeighborPeerDescriptors())
+        expect(layer1Node4.getAllNeighborPeerDescriptors()).toContainValues(layer0Node4.getAllNeighborPeerDescriptors())
 
     }, 60000)
 })

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -42,9 +42,9 @@ describe('multiple entry point joining', () => {
                 node2.joinDht(entryPoints),
                 node3.joinDht(entryPoints)
             ])
-            expect(node1.getBucketSize()).toEqual(2)
-            expect(node2.getBucketSize()).toEqual(2)
-            expect(node3.getBucketSize()).toEqual(2)
+            expect(node1.getNumberOfNeighbors()).toEqual(2)
+            expect(node2.getNumberOfNeighbors()).toEqual(2)
+            expect(node3.getNumberOfNeighbors()).toEqual(2)
         })
 
         it('can join even if a node is offline', async () => {
@@ -53,8 +53,8 @@ describe('multiple entry point joining', () => {
                 node1.joinDht(entryPoints),
                 node2.joinDht(entryPoints)
             ])
-            expect(node1.getBucketSize()).toEqual(1)
-            expect(node2.getBucketSize()).toEqual(1)
+            expect(node1.getNumberOfNeighbors()).toEqual(1)
+            expect(node2.getNumberOfNeighbors()).toEqual(1)
         }, 10000)
     })
 
@@ -96,9 +96,9 @@ describe('multiple entry point joining', () => {
 
         it('non-entry point nodes can join', async () => {
             await node1.joinDht(entryPoints)
-            expect(node1.getBucketSize()).toEqual(2)
+            expect(node1.getNumberOfNeighbors()).toEqual(2)
             await node2.joinDht(entryPoints)
-            expect(node2.getBucketSize()).toEqual(3)
+            expect(node2.getNumberOfNeighbors()).toEqual(3)
         })
 
     })

package/test/integration/ReplicateData.test.ts

@@ -80,7 +80,12 @@ describe('Replicate data from node to node in DHT', () => {
 
         // calculate offline which node is closest to the data
 
-        const sortedList = new SortedContactList<Contact>(dataKey, 10000)
+        const sortedList = new SortedContactList<Contact>({ 
+            referenceId: dataKey, 
+            maxSize: 10000, 
+            allowToContainReferenceId: true, 
+            emitEvents: false 
+        })
 
         nodes.forEach((node) => {
             sortedList.addContact(new Contact(node.getLocalPeerDescriptor())