@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.0

package/test/benchmark/Find.test.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-console */
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
@@ -15,12 +15,9 @@ const logger = new Logger(module)
 describe('Find correctness', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.NONE)
     const NUM_NODES = 1000
 
-    const nodeIndicesById: Record<string, number> = {}
-
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('ground truth data does not exist yet, generating..')
         execSync('npm run prepare-kademlia-simulation')
@@ -31,20 +28,10 @@ describe('Find correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined)
-        nodes.push(entryPoint)
-        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            nodeId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entryPoint = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[0].data), undefined)
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined)
-            nodeIndicesById[node.getNodeId().toKey()] = i
+            const node = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[i].data), undefined)
             nodes.push(node)
         }
     })
@@ -57,10 +44,10 @@ describe('Find correctness', () => {
     })
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
 
         await Promise.all(
-            nodes.map((node) => node.joinDht([entrypointDescriptor]))
+            nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()]))
         )
 
         logger.info('waiting 120s')
@@ -77,11 +64,11 @@ describe('Find correctness', () => {
             + ', weakLocked: ' + node.getNumberOfWeakLockedConnections()))
 
         logger.info('starting find')
-        const nodeIdToFind = Uint8Array.from(dhtIds[9].data)
-        const results = await nodes[159].startFind(nodeIdToFind)
+        const targetId = Uint8Array.from(dhtIds[9].data)
+        const results = await nodes[159].executeRecursiveOperation(targetId, RecursiveOperation.FIND_NODE)
         logger.info('find over')
         expect(results.closestNodes).toBeGreaterThanOrEqual(5)
-        expect(PeerID.fromValue(nodeIdToFind).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
+        expect(PeerID.fromValue(targetId).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
 
     }, 180000)
 })

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,21 +1,19 @@
 /* eslint-disable no-console */
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerID } from '../../src/helpers/PeerID'
 import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
+import { NodeID } from '../../src/helpers/nodeId'
 
 describe('Kademlia correctness', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
-    let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator()
     const NUM_NODES = 1000
 
-    const nodeIndicesById: Record<string, number> = {}
+    const nodeIndicesById: Record<NodeID, number> = {}
 
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('gound truth data does not exist yet, generating..')
@@ -29,20 +27,13 @@ describe('Kademlia correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), 8)
+        entryPoint = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[0].data), 8)
         nodes.push(entryPoint)
-        nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            nodeId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        nodeIndicesById[entryPoint.getNodeId()] = 0
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data))
-            nodeIndicesById[node.getNodeId().toKey()] = i
+            const node = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[i].data))
+            nodeIndicesById[node.getNodeId()] = i
             nodes.push(node)
         }
     })
@@ -55,10 +46,10 @@ describe('Kademlia correctness', () => {
     })
 
     it('Can find correct neighbors', async () => {
-        await entryPoint.joinDht([entrypointDescriptor])
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
 
         await Promise.allSettled(
-            nodes.map((node) => node.joinDht([entrypointDescriptor]))
+            nodes.map((node) => node.joinDht([entryPoint.getLocalPeerDescriptor()]))
         )
 
         let minimumCorrectNeighbors = Number.MAX_SAFE_INTEGER
@@ -72,17 +63,17 @@ describe('Kademlia correctness', () => {
                 groundTruthString += groundTruth[i + ''][j].name + ','
             }
 
-            const kademliaNeighbors = nodes[i].getClosestContacts().map((p) => PeerID.fromValue(p.nodeId))
+            const kademliaNeighbors = nodes[i].getClosestContacts().map((p) => getNodeIdFromPeerDescriptor(p))
 
             let kadString = 'kademliaNeighbors: '
             kademliaNeighbors.forEach((neighbor) => {
-                kadString += nodeIndicesById[neighbor.toKey()] + ','
+                kadString += nodeIndicesById[neighbor] + ','
             })
 
             let correctNeighbors = 0
             try {
                 for (let j = 0; j < groundTruth[i + ''].length; j++) {
-                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j].toKey()] + '')) {
+                    if (groundTruth[i + ''][j].name != (nodeIndicesById[kademliaNeighbors[j]] + '')) {
                         break
                     }
                     correctNeighbors++

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -2,20 +2,20 @@
 
 import KBucket from 'k-bucket'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { PeerID } from '../../src/helpers/PeerID'
 import crypto from 'crypto'
+import { NodeID, getNodeIdFromBinary } from '../../src/helpers/nodeId'
 
 const NUM_ADDS = 1000
 interface Item {
     id: Uint8Array
     vectorClock: number
-    getPeerId: () => PeerID
+    getNodeId: () => NodeID
 }
 
 const createRandomItem = (index: number): Item => {
     const rand = new Uint8Array(crypto.randomBytes(20))
     return {
-        getPeerId: () => PeerID.fromValue(rand),
+        getNodeId: () => getNodeIdFromBinary(rand),
         id: rand,
         vectorClock: index
     }
@@ -37,7 +37,7 @@ describe('SortedContactListBenchmark', () => {
             randomIds.push(createRandomItem(i))
         }
         const list = new SortedContactList({
-            referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+            referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
             allowToContainReferenceId: true,
             emitEvents: true
         })
@@ -49,7 +49,7 @@ describe('SortedContactListBenchmark', () => {
         console.timeEnd('SortedContactList.addContact() with emitEvents=true')
 
         const list2 = new SortedContactList({
-            referenceId: PeerID.fromValue(crypto.randomBytes(20)),
+            referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
             allowToContainReferenceId: true,
             emitEvents: false
         })
@@ -83,7 +83,7 @@ describe('SortedContactListBenchmark', () => {
         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)),
+                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: true
             })
@@ -97,7 +97,7 @@ describe('SortedContactListBenchmark', () => {
         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)),
+                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -111,7 +111,7 @@ describe('SortedContactListBenchmark', () => {
         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)),
+                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -125,7 +125,7 @@ describe('SortedContactListBenchmark', () => {
         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)),
+                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })

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

@@ -1,32 +1,33 @@
-import { PeerID } from '../../../src/helpers/PeerID'
 import type { SimulationNode } from './SimulationNode'
 import { NodeType, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
+import { NodeID } from '../../../src/helpers/nodeId'
+import { hexToBinary } from '@streamr/utils'
 
 export class Contact {
     private static counter = 0
 
-    public peerId: PeerID
+    public ownId: NodeID
     public id: Uint8Array
     public vectorClock = 0
     public dhtNode: SimulationNode | undefined
 
-    constructor(ownId: PeerID, dhtNode?: SimulationNode) {
-        this.peerId = ownId
+    constructor(ownId: NodeID, dhtNode?: SimulationNode) {
+        this.ownId = ownId
         this.vectorClock = Contact.counter++
         this.dhtNode = dhtNode
-        this.id = ownId.value
+        this.id = hexToBinary(ownId)
     }
 
     getPeerDescriptor(): PeerDescriptor {
         const peerDescriptor: PeerDescriptor = {
-            nodeId: this.peerId.value,
+            nodeId: hexToBinary(this.ownId),
             type: NodeType.NODEJS
         }
         return peerDescriptor
     }
 
-    getPeerId(): PeerID {
-        return this.peerId
+    getNodeId(): NodeID {
+        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 { getNodeIdFromBinary } from '../../../src/helpers/nodeId'
 
 export class KademliaSimulation {
     
@@ -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(getNodeIdFromBinary(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])

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

@@ -1,7 +1,8 @@
 import KBucket from 'k-bucket'
 import { Contact } from './Contact'
 import { SortedContactList } from '../../../src/dht/contact/SortedContactList'
-import { PeerID } from '../../../src/helpers/PeerID'
+import { NodeID, areEqualNodeIds } from '../../../src/helpers/nodeId'
+import { hexToBinary } from '@streamr/utils'
 
 export class SimulationNode {
 
@@ -16,18 +17,18 @@ export class SimulationNode {
     private numberOfOutgoingRpcCalls = 0
 
     private neighborList: SortedContactList<Contact>
-    private ownId: PeerID
+    private ownId: NodeID
 
-    constructor(ownId: PeerID) {
+    constructor(ownId: NodeID) {
         this.ownId = ownId
         this.ownContact = new Contact(this.ownId, this)
         this.bucket = new KBucket({
-            localNodeId: this.ownId.value,
+            localNodeId: hexToBinary(this.ownId),
             numberOfNodesPerKBucket: this.numberOfNodesPerKBucket
         })
 
         this.neighborList = new SortedContactList({ 
-            referenceId: this.ownId, 
+            referenceId: this.ownId,
             maxSize: 1000,
             allowToContainReferenceId: false,
             emitEvents: false
@@ -57,23 +58,22 @@ export class SimulationNode {
 
     // RPC call
 
-    public getClosestNodesTo(id: PeerID, caller: SimulationNode): Contact[] {
+    public getClosestNodesTo(id: NodeID, 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)
+        const idValue = hexToBinary(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)
+            shortlist.setContacted(contact.getNodeId())
+            shortlist.setActive(contact.getNodeId())
             this.numberOfOutgoingRpcCalls++
             const returnedContacts = contact.dhtNode!.getClosestNodesTo(this.ownId, this)
             shortlist.addContacts(returnedContacts)
@@ -86,12 +86,12 @@ export class SimulationNode {
     }
 
     public joinDht(entryPoint: SimulationNode): void {
-        if (entryPoint.getContact().peerId.equals(this.ownId)) {
+        if (areEqualNodeIds(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(hexToBinary(this.ownId), this.ALPHA)
 
         this.neighborList.addContacts(closest)
 
@@ -105,7 +105,7 @@ export class SimulationNode {
 
             this.findMoreContacts(uncontacted, this.neighborList)
 
-            if (oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
+            if (areEqualNodeIds(oldClosestContactId, this.neighborList.getClosestContactId())) {
                 uncontacted = this.neighborList.getUncontactedContacts(this.K)
                 if (uncontacted.length === 0) {
                     return
@@ -116,7 +116,7 @@ export class SimulationNode {
                     this.findMoreContacts(uncontacted, this.neighborList)
 
                     if (this.neighborList.getActiveContacts().length >= this.K ||
-                        oldClosestContactId.equals(this.neighborList.getClosestContactId())) {
+                        areEqualNodeIds(oldClosestContactId, this.neighborList.getClosestContactId())) {
                         return
                     }
                     uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)

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 { createMockPeerDescriptor } from '../utils/utils'
 
-describe('Layer0-Layer1', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        nodeId: 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,10 +62,10 @@ 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.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)

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 = {
-        nodeId: 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
         })

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

@@ -1,30 +1,24 @@
 import { binaryToHex } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
-    const entrypointDescriptor: PeerDescriptor = {
-        nodeId: new Uint8Array([0]),
-        type: NodeType.NODEJS,
+
+    const entrypointDescriptor = createMockPeerDescriptor({
         websocket: {
             host: '127.0.0.1',
             port: 23232,
             tls: false
         }
-    }
-
+    })
     let layer0EntryPoint: DhtNode
     let layer1Node1: DhtNode
-
     let layer0Node1: DhtNode
     let layer1EntryPoint: DhtNode
-
     let layer0Node2: DhtNode
     let layer1Node2: DhtNode
-
     let layer0Node3: DhtNode
     let layer1Node3: DhtNode
-
     let layer0Node4: DhtNode
     let layer1Node4: DhtNode
 

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

@@ -2,15 +2,14 @@ import { areEqualBinaries, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerID } from '../../src/helpers/PeerID'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('Layer0 with WebRTC connections', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('entrypoint').value,
-        type: NodeType.NODEJS,
+
+    const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 10029, tls: false }
-    }
+    })
     let epDhtNode: DhtNode
     let node1: DhtNode
     let node2: DhtNode

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

@@ -1,29 +1,21 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_ID = 'stream'
+const NUM_OF_NODES = 16
 const NUM_OF_NODES_PER_KBUCKET = 8
+const WEBSOCKET_PORT_RANGE = { min: 62200, max: 62200 + NUM_OF_NODES }
 
 describe('Layer1 Scale', () => {
-    const epPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('entrypoint').value,
-        type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43225, tls: false }
-    }
-
-    const STREAM_ID = 'stream'
-
-    const NUM_OF_NODES = 16
 
+    const epPeerDescriptor = createMockPeerDescriptor({
+        websocket: { host: '127.0.0.1', port: 43225, tls: false }
+    })
     let layer0Nodes: DhtNode[]
-
     let layer1Nodes: DhtNode[]
-
     let epLayer0Node: DhtNode
     let epLayer1Node: DhtNode
 
-    const websocketPortRange = { min: 62200, max: 62200 + NUM_OF_NODES }
-
     beforeEach(async () => {
         epLayer0Node = new DhtNode({
             peerDescriptor: epPeerDescriptor,
@@ -41,7 +33,7 @@ describe('Layer1 Scale', () => {
 
         for (let i = 0; i < NUM_OF_NODES; i++) {
             const node = new DhtNode({ 
-                websocketPortRange,
+                websocketPortRange: WEBSOCKET_PORT_RANGE,
                 entryPoints: [epPeerDescriptor],
                 websocketServerEnableTls: false,
                 numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET