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

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/Contact.ts

@@ -19,7 +19,7 @@ export class Contact {
 
     getPeerDescriptor(): PeerDescriptor {
         const peerDescriptor: PeerDescriptor = {
-            kademliaId: this.peerId.value,
+            nodeId: this.peerId.value,
             type: NodeType.NODEJS
         }
         return peerDescriptor

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

@@ -17,7 +17,7 @@ export class KademliaSimulation {
 
     constructor() {
         if (!fs.existsSync('test/data/nodeids.json')) {
-            throw ('Cannot find test/data/nodeids.json, please run "npm run prepare-kademlia-simulation first"')
+            throw new Error('Cannot find test/data/nodeids.json, please run "npm run prepare-kademlia-simulation first"')
         }
         this.dhtIds = JSON.parse(fs.readFileSync('test/data/nodeids.json').toString())
         this.groundTruth = JSON.parse(fs.readFileSync('test/data/orderedneighbors.json').toString())

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-Layer1.test.ts

@@ -4,7 +4,7 @@ import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescrip
 
 describe('Layer0-Layer1', () => {
     const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: Uint8Array.from([1, 2, 3]),
+        nodeId: Uint8Array.from([1, 2, 3]),
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 10016, tls: false }
     }

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

@@ -7,7 +7,7 @@ import { TransportEvents } from '../../src/transport/ITransport'
 describe('Layer0MixedConnectionTypes', () => {
 
     const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: Uint8Array.from([1, 2, 3]),
+        nodeId: Uint8Array.from([1, 2, 3]),
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 11221, tls: false }
     }
@@ -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

@@ -4,7 +4,7 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
     const entrypointDescriptor: PeerDescriptor = {
-        kademliaId: new Uint8Array([0]),
+        nodeId: new Uint8Array([0]),
         type: NodeType.NODEJS,
         websocket: {
             host: '127.0.0.1',
@@ -53,7 +53,7 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         })
 
         layer1EntryPoint = new DhtNode({
-            peerId: binaryToHex(entrypointDescriptor.kademliaId),
+            peerId: binaryToHex(entrypointDescriptor.nodeId),
             transport: layer0EntryPoint,
             serviceId: 'layer1'
         })
@@ -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/Layer0Webrtc.test.ts

@@ -7,7 +7,7 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 
 describe('Layer0 with WebRTC connections', () => {
     const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('entrypoint').value,
+        nodeId: PeerID.fromString('entrypoint').value,
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 10029, tls: false }
     }
@@ -61,7 +61,7 @@ describe('Layer0 with WebRTC connections', () => {
                 'connected',
                 20000,
                 (peerDescriptor: PeerDescriptor) => {
-                    return areEqualBinaries(peerDescriptor.kademliaId, node1.getLocalPeerDescriptor().kademliaId)
+                    return areEqualBinaries(peerDescriptor.nodeId, node1.getLocalPeerDescriptor().nodeId)
                 }
             ),
             node2.joinDht([epPeerDescriptor]),

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

@@ -6,7 +6,7 @@ const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1 Scale', () => {
     const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('entrypoint').value,
+        nodeId: PeerID.fromString('entrypoint').value,
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 43225, tls: false }
     }
@@ -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

@@ -6,7 +6,7 @@ const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1 Scale', () => {
     const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('0').value,
+        nodeId: PeerID.fromString('0').value,
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 43228, tls: false }
     }
@@ -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/WebsocketConnectionRequest.test.ts

@@ -7,7 +7,7 @@ import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescrip
 
 describe('Websocket IConnection Requests', () => {
     const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('3').value,
+        nodeId: PeerID.fromString('3').value,
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 10021, tls: false }
     }

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

@@ -11,7 +11,7 @@ describe('memory leak', () => {
 
     it('send message', async () => {
         const entryPointDescriptor = {
-            kademliaId: randomBytes(10),
+            nodeId: randomBytes(10),
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -20,7 +20,7 @@ describe('memory leak', () => {
             }
         }
         let entryPoint: DhtNode | undefined = new DhtNode({
-            peerId: binaryToHex(entryPointDescriptor.kademliaId),
+            peerId: binaryToHex(entryPointDescriptor.nodeId),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
                 min: entryPointDescriptor.websocket.port,
@@ -33,20 +33,16 @@ describe('memory leak', () => {
         await entryPoint.joinDht([entryPointDescriptor])
         let sender: DhtNode | undefined = new DhtNode({})
         let receiver: DhtNode | undefined = new DhtNode({})
-        /*TODO should this work? await Promise.all([
-            async () => {
+        await Promise.all([
+            (async () => {
                 await sender.start()
                 await sender.joinDht([entryPointDescriptor])
-            },
-            async () => {
+            })(),
+            (async () => {
                 await receiver.start()
                 await receiver.joinDht([entryPointDescriptor])
-            }
-        ])*/
-        await sender.start()
-        await sender.joinDht([entryPointDescriptor])
-        await receiver.start()
-        await receiver.joinDht([entryPointDescriptor])
+            })()
+        ])
 
         let receivedMessage: Message | undefined = undefined
         receiver.on('message', (msg: Message) => receivedMessage = msg)
@@ -72,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/ConnectionLocking.test.ts

@@ -21,12 +21,12 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
 describe('Connection Locking', () => {
 
     const mockPeerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('mock1').value,
+        nodeId: PeerID.fromString('mock1').value,
         type: NodeType.NODEJS,
         region: getRandomRegion()
     }
     const mockPeerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('mock2').value,
+        nodeId: PeerID.fromString('mock2').value,
         type: NodeType.NODEJS,
         region: getRandomRegion()
     }

package/test/integration/ConnectionManager.test.ts

@@ -8,7 +8,7 @@ import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/exports'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { MarkOptional } from 'ts-essentials'
-import { createRandomKademliaId } from '../../src/helpers/kademliaId'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 import { TransportEvents } from '../../src/transport/ITransport'
 
 const logger = new Logger(module)
@@ -18,20 +18,20 @@ describe('ConnectionManager', () => {
     const serviceId = 'demo'
 
     const mockPeerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester1').value,
+        nodeId: PeerID.fromString('tester1').value,
         type: NodeType.NODEJS
     }
     const mockPeerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester2').value,
+        nodeId: PeerID.fromString('tester2').value,
         type: NodeType.NODEJS
     }
 
     const mockPeerDescriptor3: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester3').value,
+        nodeId: PeerID.fromString('tester3').value,
         type: NodeType.NODEJS
     }
     const mockPeerDescriptor4: PeerDescriptor = {
-        kademliaId: PeerID.fromString('tester4').value,
+        nodeId: PeerID.fromString('tester4').value,
         type: NodeType.NODEJS
     }
     const simulator = new Simulator()
@@ -89,7 +89,7 @@ describe('ConnectionManager', () => {
             transport: mockTransport,
             websocketPortRange: { min: 9992, max: 9992 },
             entryPoints: [
-                { kademliaId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 12345, tls: false } }
+                { nodeId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 12345, tls: false } }
             ]
         })
 
@@ -112,7 +112,7 @@ describe('ConnectionManager', () => {
             transport: mockConnectorTransport2,
             websocketPortRange: { min: 9994, max: 9994 },
             entryPoints: [
-                { kademliaId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 9993, tls: false } }
+                { nodeId: Uint8Array.from([1, 2, 3]), type: NodeType.NODEJS, websocket: { host: '127.0.0.1', port: 9993, tls: false } }
             ]
         })
 
@@ -306,7 +306,7 @@ describe('ConnectionManager', () => {
         await connectionManager4.stop()
     })
 
-    it('Cannot send to own WebsocketServer if kademliaIds do not match', async () => {
+    it('Cannot send to own WebsocketServer if nodeIds do not match', async () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
@@ -317,7 +317,7 @@ describe('ConnectionManager', () => {
         expect(createLocalPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
         
         const peerDescriptor = connectionManager1.getLocalPeerDescriptor()
-        peerDescriptor.kademliaId = new Uint8Array([12, 12, 12, 12])
+        peerDescriptor.nodeId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {
             serviceId,
             messageType: MessageType.RPC,
@@ -335,10 +335,10 @@ describe('ConnectionManager', () => {
         await connectionManager1.stop()
     })
 
-    it('Cannot send to a WebSocketServer if kademliaIds do not match', async () => {
+    it('Cannot send to a WebSocketServer if nodeIds do not match', async () => {
 
         const peerDescriptor1 = {
-            kademliaId: createRandomKademliaId(),
+            nodeId: createRandomNodeId(),
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -348,7 +348,7 @@ describe('ConnectionManager', () => {
         }
 
         const peerDescriptor2 = {
-            kademliaId: createRandomKademliaId(),
+            nodeId: createRandomNodeId(),
             type: NodeType.NODEJS,
             websocket: {
                 host: '127.0.0.1',
@@ -379,8 +379,8 @@ describe('ConnectionManager', () => {
             messageType: MessageType.RPC,
             messageId: '1',
             targetDescriptor: {
-                // This is not the correct kademliaId of peerDescriptor2
-                kademliaId: new Uint8Array([1, 2, 3, 4]),
+                // This is not the correct nodeId of peerDescriptor2
+                nodeId: new Uint8Array([1, 2, 3, 4]),
                 type: NodeType.NODEJS,
                 websocket: peerDescriptor2.websocket
             },

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -11,7 +11,7 @@ const runTest = async (latencyType: LatencyType) => {
     const entryPointId = '0'
     const entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
     const entrypointDescriptor = {
-        kademliaId: entryPoint.getNodeId().value,
+        nodeId: entryPoint.getNodeId().value,
         type: NodeType.NODEJS,
         region: getRandomRegion()
     }
@@ -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/DhtNodeExternalAPI.test.ts

@@ -1,9 +1,10 @@
 import { DhtNode } from '../../src/dht/DhtNode'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { createMockConnectionDhtNode } from '../utils/utils'
+import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 describe('DhtNodeExternalApi', () => {
 
@@ -28,7 +29,7 @@ describe('DhtNodeExternalApi', () => {
 
     it('findData happy path', async () => {
         const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
-        const key = PeerID.fromString('key').value
+        const key = createRandomNodeId()
         await dhtNode1.storeDataToDht(key, data)
 
         const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
@@ -36,17 +37,19 @@ describe('DhtNodeExternalApi', () => {
     })
     
     it('findData returns empty array if no data found', async () => {
-        const foundData = await remote.findDataViaPeer(PeerID.fromString('key').value, dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(createRandomNodeId(), dhtNode1.getLocalPeerDescriptor())
         expect(foundData).toEqual([])
     })
 
     it('external store data happy path', async () => {
-        const data = Any.pack(dhtNode1.getLocalPeerDescriptor(), PeerDescriptor)
-        const key = PeerID.fromString('key').value 
+        const storedPeerDescriptor = createMockPeerDescriptor()
+        const data = Any.pack(storedPeerDescriptor, PeerDescriptor)
+        const key = createRandomNodeId()
 
         await remote.storeDataViaPeer(key, data, dhtNode1.getLocalPeerDescriptor())
         const foundData = await remote.findDataViaPeer(key, dhtNode1.getLocalPeerDescriptor())
-        expect(Any.unpack(foundData[0].data!, PeerDescriptor)).toEqual(dhtNode1.getLocalPeerDescriptor())
+        expect(areEqualPeerDescriptors(Any.unpack(foundData[0].data!, PeerDescriptor), storedPeerDescriptor)).toEqual(true)
+        expect(areEqualPeerDescriptors(foundData[0].creator!, remote.getLocalPeerDescriptor())).toEqual(true)
     })
   
 })