@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

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/connection/websocket/ClientWebsocket'
+
+// 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/hybrid-network-simulation/RingContactList.test.ts

@@ -0,0 +1,72 @@
+import { ConnectivityResponse, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { createPeerDescriptor } from '../../../src/helpers/createPeerDescriptor'
+import { NatType } from '../../../src/connection/ConnectionManager'
+import { ipv4ToNumber, Logger } from '@streamr/utils'
+import { RingContactList } from '../../../src/dht/contact/RingContactList'
+import { getRingIdRawFromPeerDescriptor } from '../../../src/dht/contact/ringIdentifiers'
+import { getRandomRegion } from '../../../src/connection/simulator/pings'
+
+const logger = new Logger(module)
+
+function ipv4ToString(ip: number): string {
+    return [
+        (ip >>> 24) & 0xFF,
+        (ip >>> 16) & 0xFF,
+        (ip >>> 8) & 0xFF,
+        ip & 0xFF
+    ].join('.')
+}
+
+class MockNode {
+    private readonly peerDescriptor: PeerDescriptor
+
+    constructor(_region: number, ipAddress: string) {
+
+        const connectivityResponse: ConnectivityResponse = {
+            host: 'localhost',
+            natType: NatType.UNKNOWN,
+            ipAddress: ipv4ToNumber(ipAddress),
+            version: '0.0.0'
+
+        }
+        this.peerDescriptor = createPeerDescriptor(connectivityResponse, getRandomRegion())
+        logger.info(ipv4ToString(this.peerDescriptor.ipAddress!))
+    }
+
+    public getPeerDescriptor(): PeerDescriptor {
+        return this.peerDescriptor
+    }
+}
+
+// populate with mock ip addresses
+const mockData: Array< [number, string] > = [
+    [0, '5.2.4.2'],
+    [0, '6.23.2.4'],
+    [0, '7.2.4.2'],
+    [0, '8.23.2.4'],
+    [0, '9.3.2.4'],
+    [0, '10.3.2.4'],
+    [0, '24.23.2.4'],
+    [0, '31.23.2.4'],
+    [0, '33.2.4.2'],
+    [0, '35.3.2.4'],
+    [0, '37.23.2.4'],
+    [0, '39.2.4.2'],
+    [0, '42.3.2.4'],
+    [0, '46.2.4.2'],
+    [0, '48.3.2.4'],
+    [0, '50.23.2.4']
+]
+
+const mockNodes: MockNode[] = mockData.map(([region, ipAddress]) => new MockNode(region, ipAddress))
+const referenceNode = mockNodes[5]
+const ringContactList: RingContactList<MockNode> = new RingContactList<MockNode>(
+    getRingIdRawFromPeerDescriptor(referenceNode.getPeerDescriptor()),
+    false
+)
+
+mockNodes.forEach((node) => ringContactList.addContact(node))
+
+ringContactList.getClosestContacts().left.forEach((node) => logger.info(ipv4ToString(node.getPeerDescriptor().ipAddress!)))
+logger.info('reference node: ' + ipv4ToString(referenceNode.getPeerDescriptor().ipAddress!))
+ringContactList.getClosestContacts().right.forEach((node) => logger.info(ipv4ToString(node.getPeerDescriptor().ipAddress!)))

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

@@ -1,32 +1,32 @@
-import { PeerID } from '../../../src/helpers/PeerID'
 import type { SimulationNode } from './SimulationNode'
 import { NodeType, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../../../src/identifiers'
 
 export class Contact {
     private static counter = 0
 
-    public peerId: PeerID
-    public id: Uint8Array
+    public ownId: DhtAddress
+    public id: DhtAddressRaw
     public vectorClock = 0
     public dhtNode: SimulationNode | undefined
 
-    constructor(ownId: PeerID, dhtNode?: SimulationNode) {
-        this.peerId = ownId
+    constructor(ownId: DhtAddress, dhtNode?: SimulationNode) {
+        this.ownId = ownId
         this.vectorClock = Contact.counter++
         this.dhtNode = dhtNode
-        this.id = ownId.value
+        this.id = getRawFromDhtAddress(ownId)
     }
 
     getPeerDescriptor(): PeerDescriptor {
         const peerDescriptor: PeerDescriptor = {
-            kademliaId: this.peerId.value,
+            nodeId: getRawFromDhtAddress(this.ownId),
             type: NodeType.NODEJS
         }
         return peerDescriptor
     }
 
-    getPeerId(): PeerID {
-        return this.peerId
+    getNodeId(): DhtAddress {
+        return this.ownId
     }
 
 }

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

@@ -2,7 +2,7 @@
 
 import { SimulationNode } from './SimulationNode'
 import fs from 'fs'
-import { PeerID } from '../../../src/helpers/PeerID'
+import { getDhtAddressFromRaw } from '../../../src/identifiers'
 
 export class KademliaSimulation {
     
@@ -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())
@@ -25,7 +25,7 @@ export class KademliaSimulation {
 
     public run(): void {
         for (let i = 0; i < KademliaSimulation.NUM_NODES; i++) {
-            const node = new SimulationNode(PeerID.fromValue(Buffer.from(this.dhtIds[i].data.slice(0, KademliaSimulation.ID_LENGTH))))
+            const node = new SimulationNode(getDhtAddressFromRaw(Buffer.from(this.dhtIds[i].data.slice(0, KademliaSimulation.ID_LENGTH))))
             this.nodeNamesById[JSON.stringify(node.getContact().id)] = i
             this.nodes.push(node)
             node.joinDht(this.nodes[0])
@@ -42,17 +42,17 @@ export class KademliaSimulation {
 
         for (let i = this.nodes.length - 1; i >= 0; i--) {
             
-            const numberOfOutgoingRpcCalls = this.nodes[i].getNumberOfOutgoingRpcCalls()
+            const outgoingRpcCallCount = this.nodes[i].getOutgoingRpcCallCount()
             console.log('-----------')
             console.log('Node: ' + i)
             console.log('Kbucket size: ' + this.nodes[i].getKBucketSize())
-            console.log('Num incoming RPC calls: ' + this.nodes[i].getNumberOfIncomingRpcCalls())
-            console.log('Num outgoing RPC calls: ' + numberOfOutgoingRpcCalls)
+            console.log('Num incoming RPC calls: ' + this.nodes[i].getIncomingRpcCallCount())
+            console.log('Num outgoing RPC calls: ' + outgoingRpcCallCount)
     
-            sumOutgoingRpcCalls += numberOfOutgoingRpcCalls
+            sumOutgoingRpcCalls += outgoingRpcCallCount
     
-            if (maxOutgoingRpcCalls < numberOfOutgoingRpcCalls) {
-                maxOutgoingRpcCalls = numberOfOutgoingRpcCalls
+            if (maxOutgoingRpcCalls < outgoingRpcCallCount) {
+                maxOutgoingRpcCalls = outgoingRpcCallCount
             }
 
             const kademliaNeighbors = this.nodes[i].getNeightborList().getContactIds()
@@ -79,13 +79,13 @@ export class KademliaSimulation {
 
         const avgCorrectNeighbors = sumCorrectNeighbors / (KademliaSimulation.NUM_NODES - 1)
         const avgKbucketSize = sumKbucketSize / (KademliaSimulation.NUM_NODES - 1)
-        const avgNumberOfOutgoingRpcCalls = sumOutgoingRpcCalls / (KademliaSimulation.NUM_NODES - 1)
+        const avgOutgoingRpcCallCount = sumOutgoingRpcCalls / (KademliaSimulation.NUM_NODES - 1)
 
         console.log('----------- Simulation results ------------------')
         console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
         console.log('Average correct neighbors: ' + avgCorrectNeighbors)
         console.log('Average Kbucket size: ' + avgKbucketSize)
-        console.log('Average number of outgoing RPC calls: ' + avgNumberOfOutgoingRpcCalls)
+        console.log('Average number of outgoing RPC calls: ' + avgOutgoingRpcCallCount)
         console.log('MAX number of outgoing RPC calls: ' + maxOutgoingRpcCalls)
     }
 }

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

@@ -1,7 +1,7 @@
 import KBucket from 'k-bucket'
 import { Contact } from './Contact'
 import { SortedContactList } from '../../../src/dht/contact/SortedContactList'
-import { PeerID } from '../../../src/helpers/PeerID'
+import { DhtAddress, getRawFromDhtAddress } from '../../../src/identifiers'
 
 export class SimulationNode {
 
@@ -12,21 +12,26 @@ export class SimulationNode {
     private bucket: KBucket<Contact>
     private ownContact: Contact
 
-    private numberOfIncomingRpcCalls = 0
-    private numberOfOutgoingRpcCalls = 0
+    private incomingRpcCallCount = 0
+    private outgoingRpcCallCount = 0
 
     private neighborList: SortedContactList<Contact>
-    private ownId: PeerID
+    private ownId: DhtAddress
 
-    constructor(ownId: PeerID) {
+    constructor(ownId: DhtAddress) {
         this.ownId = ownId
         this.ownContact = new Contact(this.ownId, this)
         this.bucket = new KBucket({
-            localNodeId: this.ownId.value,
+            localNodeId: getRawFromDhtAddress(this.ownId),
             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
@@ -42,34 +47,33 @@ export class SimulationNode {
         return this.bucket.count()
     }
 
-    public getNumberOfIncomingRpcCalls(): number {
-        return this.numberOfIncomingRpcCalls
+    public getIncomingRpcCallCount(): number {
+        return this.incomingRpcCallCount
     }
 
-    public getNumberOfOutgoingRpcCalls(): number {
-        return this.numberOfOutgoingRpcCalls
+    public getOutgoingRpcCallCount(): number {
+        return this.outgoingRpcCallCount
     }
 
     // RPC call
 
-    public getClosestNodesTo(id: PeerID, caller: SimulationNode): Contact[] {
-        this.numberOfIncomingRpcCalls++
-        const ret = this.bucket.closest(id.value)
-
-        if (!this.bucket.get(id.value)) {
-            const contact = new Contact(PeerID.fromValue(id.value), caller)
+    public getClosestNodesTo(id: DhtAddress, caller: SimulationNode): Contact[] {
+        this.incomingRpcCallCount++
+        const idValue = getRawFromDhtAddress(id)
+        const ret = this.bucket.closest(idValue)
+        if (!this.bucket.get(idValue)) {
+            const contact = new Contact(id, caller)
             this.bucket.add(contact)
             this.neighborList.addContact(contact)
         }
-
         return ret
     }
 
     private findMoreContacts(contactList: Contact[], shortlist: SortedContactList<Contact>) {
         contactList.forEach((contact) => {
-            shortlist.setContacted(contact.peerId)
-            shortlist.setActive(contact.peerId)
-            this.numberOfOutgoingRpcCalls++
+            shortlist.setContacted(contact.getNodeId())
+            shortlist.setActive(contact.getNodeId())
+            this.outgoingRpcCallCount++
             const returnedContacts = contact.dhtNode!.getClosestNodesTo(this.ownId, this)
             shortlist.addContacts(returnedContacts)
             returnedContacts.forEach((returnedContact: Contact) => {
@@ -81,12 +85,12 @@ export class SimulationNode {
     }
 
     public joinDht(entryPoint: SimulationNode): void {
-        if (entryPoint.getContact().peerId.equals(this.ownId)) {
+        if (entryPoint.getContact().getNodeId() === this.ownId) {
             return
         }
 
         this.bucket.add(entryPoint.getContact())
-        const closest = this.bucket.closest(this.ownId.value, this.ALPHA)
+        const closest = this.bucket.closest(getRawFromDhtAddress(this.ownId), this.ALPHA)
 
         this.neighborList.addContacts(closest)
 
@@ -100,7 +104,7 @@ export class SimulationNode {
 
             this.findMoreContacts(uncontacted, this.neighborList)
 
-            if (oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
+            if (oldClosestContactId === this.neighborList.getClosestContactId()) {
                 uncontacted = this.neighborList.getUncontactedContacts(this.K)
                 if (uncontacted.length === 0) {
                     return
@@ -111,7 +115,7 @@ export class SimulationNode {
                     this.findMoreContacts(uncontacted, this.neighborList)
 
                     if (this.neighborList.getActiveContacts().length >= this.K ||
-                        oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
+                        (oldClosestContactId === this.neighborList.getClosestContactId())) {
                         return
                     }
                     uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)

package/test/data/generateGroundTruthData.ts

@@ -1,16 +1,17 @@
 import fs from 'fs'
 import crypto from 'crypto'
 import KBucket from 'k-bucket'
+import { DhtAddressRaw } from '../../src/identifiers'
 
-const ID_LENGTH = 8
-const NUM_NODES = 2000
+const ID_LENGTH = 20
+const NUM_NODES = 900
 const NUM_NEAREST = 10
 
-const generateId = function(): Uint8Array {
+const generateId = function(): DhtAddressRaw {
     return crypto.randomBytes(ID_LENGTH)
 }
 
-const findNNearestNeighbors = function(ownIndex: number, ownId: Uint8Array, nodes: Array<Uint8Array>, n: number): Array<number> {
+const findNNearestNeighbors = function(ownIndex: number, ownId: DhtAddressRaw, nodes: Array<DhtAddressRaw>, n: number): Array<number> {
     const retIndex: Array<number> = []
 
     for (let i = 0; i < n; i++) {
@@ -37,7 +38,7 @@ const neighborWriter = fs.createWriteStream('orderedneighbors.json', {})
 
 neighborWriter.write('{\n')
 
-const nodes: Array<Uint8Array> = []
+const nodes: Array<DhtAddressRaw> = []
 
 // generate nodeIds
 
@@ -53,7 +54,7 @@ for (let i = 0; i < NUM_NODES; i++) {
 
     const neighborIds = findNNearestNeighbors(i, nodes[i], nodes, NUM_NEAREST)
 
-    const neighborNames: Array<{ name: number, distance: number, id: Uint8Array }> = []
+    const neighborNames: Array<{ name: number, distance: number, id: DhtAddressRaw }> = []
     // eslint-disable-next-line @typescript-eslint/prefer-for-of
     for (let j = 0; j < neighborIds.length; j++) {
         neighborNames.push({ name: neighborIds[j], distance: KBucket.distance(nodes[i], nodes[neighborIds[j]]), id: nodes[neighborIds[j]] })

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

@@ -1,28 +1,24 @@
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/identifiers'
+import { createMockPeerDescriptor } from '../utils/utils'
 
-describe('Layer0-Layer1', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: Uint8Array.from([1, 2, 3]),
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 10016, tls: false }
-    }
+const STREAM_ID1 = 'stream1'
+const STREAM_ID2 = 'stream2'
+const WEBSOCKET_PORT_RANGE = { min: 10017, max: 10018 }
 
-    const STREAM_ID1 = 'stream1'
-    const STREAM_ID2 = 'stream2'
+describe('Layer0-Layer1', () => {
 
+    const epPeerDescriptor = createMockPeerDescriptor({
+        websocket: { host: '127.0.0.1', port: 10016, tls: false }
+    })
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode
-
     let stream1Node1: DhtNode
     let stream1Node2: DhtNode
     let stream2Node1: DhtNode
     let stream2Node2: DhtNode
 
-    const websocketPortRange = { min: 10017, max: 10018 }
-
     beforeEach(async () => {
 
         epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, websocketServerEnableTls: false })
@@ -30,12 +26,12 @@ describe('Layer0-Layer1', () => {
         await epDhtNode.joinDht([epPeerDescriptor])
 
         node1 = new DhtNode({ 
-            websocketPortRange, 
+            websocketPortRange: WEBSOCKET_PORT_RANGE, 
             entryPoints: [epPeerDescriptor], 
             websocketServerEnableTls: false
         })
         node2 = new DhtNode({ 
-            websocketPortRange,
+            websocketPortRange: WEBSOCKET_PORT_RANGE,
             entryPoints: [epPeerDescriptor],
             websocketServerEnableTls: false
         })

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

@@ -1,46 +1,43 @@
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 
+const WEBSOCKET_PORT_RANGE = { min: 10012, max: 10015 } 
+
 describe('Layer0', () => {
 
-    let epPeerDescriptor: PeerDescriptor
-    
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode
     let node3: DhtNode
     let node4: DhtNode
 
-    const websocketPortRange = { min: 10012, max: 10015 } 
     beforeEach(async () => {
         
         epDhtNode = new DhtNode({ websocketHost: '127.0.0.1', websocketPortRange: { min: 10011, max: 10011 }, websocketServerEnableTls: false })
         await epDhtNode.start()
-        epPeerDescriptor = epDhtNode.getLocalPeerDescriptor()
-        await epDhtNode.joinDht([epPeerDescriptor])
+        await epDhtNode.joinDht([epDhtNode.getLocalPeerDescriptor()])
 
         node1 = new DhtNode({ 
-            websocketPortRange,
+            websocketPortRange: WEBSOCKET_PORT_RANGE,
             websocketHost: '127.0.0.1',
-            entryPoints: [epPeerDescriptor],
+            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
             websocketServerEnableTls: false
         })
         node2 = new DhtNode({ 
-            websocketPortRange,
+            websocketPortRange: WEBSOCKET_PORT_RANGE,
             websocketHost: '127.0.0.1',
-            entryPoints: [epPeerDescriptor],
+            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
             websocketServerEnableTls: false
         })
         node3 = new DhtNode({ 
-            websocketPortRange,
+            websocketPortRange: WEBSOCKET_PORT_RANGE,
             websocketHost: '127.0.0.1',
-            entryPoints: [epPeerDescriptor],
+            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
             websocketServerEnableTls: false
         })
         node4 = new DhtNode({ 
-            websocketPortRange, 
+            websocketPortRange: WEBSOCKET_PORT_RANGE, 
             websocketHost: '127.0.0.1',
-            entryPoints: [epPeerDescriptor],
+            entryPoints: [epDhtNode.getLocalPeerDescriptor()],
             websocketServerEnableTls: false
         })
         
@@ -65,15 +62,15 @@ describe('Layer0', () => {
 
     it('Happy path', async () => {
         await Promise.all([
-            node1.joinDht([epPeerDescriptor]),
-            node2.joinDht([epPeerDescriptor]),
-            node3.joinDht([epPeerDescriptor]),
-            node4.joinDht([epPeerDescriptor])
+            node1.joinDht([epDhtNode.getLocalPeerDescriptor()]),
+            node2.joinDht([epDhtNode.getLocalPeerDescriptor()]),
+            node3.joinDht([epDhtNode.getLocalPeerDescriptor()]),
+            node4.joinDht([epDhtNode.getLocalPeerDescriptor()])
         ])
 
-        expect(node1.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node2.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node3.getBucketSize()).toBeGreaterThanOrEqual(2)
-        expect(node4.getBucketSize()).toBeGreaterThanOrEqual(2)
+        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
     }, 10000)
 })

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

@@ -1,17 +1,16 @@
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { TransportEvents } from '../../src/transport/ITransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+
+const WEBSOCKET_PORT_RANGE = { min: 11222, max: 11223 }
 
 describe('Layer0MixedConnectionTypes', () => {
 
-    const epPeerDescriptor: PeerDescriptor = {
-        kademliaId: Uint8Array.from([1, 2, 3]),
-        type: NodeType.NODEJS,
+    const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 11221, tls: false }
-    }
-
+    })
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode
@@ -19,7 +18,6 @@ describe('Layer0MixedConnectionTypes', () => {
     let node4: DhtNode
     let node5: DhtNode
 
-    const websocketPortRange = { min: 11222, max: 11223 }
     beforeEach(async () => {
 
         epDhtNode = new DhtNode({ 
@@ -31,12 +29,12 @@ describe('Layer0MixedConnectionTypes', () => {
 
         await epDhtNode.joinDht([epPeerDescriptor])
         node1 = new DhtNode({ 
-            websocketPortRange,
+            websocketPortRange: WEBSOCKET_PORT_RANGE,
             entryPoints: [epPeerDescriptor],
             websocketServerEnableTls: false
         })
         node2 = new DhtNode({ 
-            websocketPortRange,
+            websocketPortRange: WEBSOCKET_PORT_RANGE,
             entryPoints: [epPeerDescriptor],
             websocketServerEnableTls: false
         })
@@ -89,13 +87,13 @@ 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.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNeighborCount()).toBeGreaterThanOrEqual(1)
 
-    }, 15000)
+    }, 20000)
 
     it('Simultaneous joins', async () => {
         await Promise.all([
@@ -105,10 +103,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)
-    }, 30000)
+        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNeighborCount()).toBeGreaterThanOrEqual(2)
+    }, 40000)
 })