@streamr/dht 0.0.1-tatum.5 → 0.0.1-tatum.7

package/src/dht/store/DataStore.ts

@@ -10,7 +10,7 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StoreServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { IRecursiveFinder } from '../find/RecursiveFinder'
-import { isSamePeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { IStoreService } from '../../proto/packages/dht/protos/DhtRpc.server'
@@ -20,7 +20,7 @@ import EventEmitter from 'eventemitter3'
 import { Events } from '../DhtNode'
 import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
-import { DhtPeer } from '../DhtPeer'
+import { RemoteDhtNode } from '../RemoteDhtNode'
 
 interface DataStoreConfig {
     rpcCommunicator: RoutingRpcCommunicator
@@ -32,7 +32,7 @@ interface DataStoreConfig {
     highestTtl: number
     numberOfCopies: number
     dhtNodeEmitter: EventEmitter<Events>
-    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtPeer[]
+    getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 }
 
 const logger = new Logger(module)
@@ -48,7 +48,7 @@ export class DataStore implements IStoreService {
     private readonly highestTtl: number
     private readonly numberOfCopies: number
     private readonly dhtNodeEmitter: EventEmitter<Events>
-    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => DhtPeer[]
+    private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 
     constructor(config: DataStoreConfig) {
         this.rpcCommunicator = config.rpcCommunicator
@@ -68,7 +68,7 @@ export class DataStore implements IStoreService {
         this.rpcCommunicator.registerRpcMethod(DeleteDataRequest, DeleteDataResponse, 'deleteData',
             (request: DeleteDataRequest, context: ServerCallContext) => this.deleteData(request, context))
 
-        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor, _closestPeers: PeerDescriptor[]) => {
+        this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor) => {
             this.localDataStore.getStore().forEach((dataMap, _dataKey) => {
                 dataMap.forEach((dataEntry) => {
                     if (this.shouldMigrateDataToNewNode(dataEntry.dataEntry, peerDescriptor)) {
@@ -151,7 +151,7 @@ export class DataStore implements IStoreService {
         const ttl = this.highestTtl // ToDo: make TTL decrease according to some nice curve
         const storerTime = Timestamp.now()
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
-            if (isSamePeerDescriptor(this.ownPeerDescriptor, closestNodes[i])) {
+            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.storeEntry({
                     kademliaId: key, 
                     storer: this.ownPeerDescriptor,
@@ -201,7 +201,7 @@ export class DataStore implements IStoreService {
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
-            if (isSamePeerDescriptor(this.ownPeerDescriptor, closestNodes[i])) {
+            if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.markAsDeleted(key, peerIdFromPeerDescriptor(this.ownPeerDescriptor))
                 successfulNodes.push(closestNodes[i])
                 continue
@@ -217,7 +217,7 @@ export class DataStore implements IStoreService {
                 if (response.deleted) {
                     logger.trace('remoteStore.deleteData() returned success')
                 } else {
-                    logger.trace('could not delete data from ' + PeerID.fromValue(closestNodes[i].kademliaId))
+                    logger.trace('could not delete data from ' + keyFromPeerDescriptor(closestNodes[i]))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {
@@ -246,7 +246,7 @@ export class DataStore implements IStoreService {
             this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(kademliaId))
         }
 
-        logger.trace(this.ownPeerDescriptor.nodeName + ' storeData()')
+        logger.trace('storeData()')
         return StoreDataResponse.create()
     }
 
@@ -260,7 +260,7 @@ export class DataStore implements IStoreService {
 
     // RPC service implementation
     public async migrateData(request: MigrateDataRequest, context: ServerCallContext): Promise<MigrateDataResponse> {
-        logger.trace(this.ownPeerDescriptor.nodeName + ' server-side migrateData()')
+        logger.trace('server-side migrateData()')
         const dataEntry = request.dataEntry!
 
         const wasStored = this.localDataStore.storeEntry(dataEntry)
@@ -271,7 +271,7 @@ export class DataStore implements IStoreService {
         if (!this.selfIsOneOfClosestPeers(dataEntry.kademliaId)) {
             this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(dataEntry.kademliaId))
         }
-        logger.trace(this.ownPeerDescriptor.nodeName + ' server-side migrateData() at end')
+        logger.trace('server-side migrateData() at end')
         return MigrateDataResponse.create()
     }
 

package/src/exports.ts

@@ -6,15 +6,8 @@ export { getRandomRegion, getRegionDelayMatrix } from './connection/Simulator/pi
 export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
 export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
-export { PeerID, PeerIDKey } from './helpers/PeerID'
-export { DhtPeer } from './dht/DhtPeer'
-export { UUID } from './helpers/UUID'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
-export { protoClasses } from './helpers/protoClasses'
-export { SortedContactList } from './dht/contact/SortedContactList'
-export { Contact } from './dht/contact/Contact'
 export { Remote } from './dht/contact/Remote'
-export { RecursiveFindResult } from './dht/find/RecursiveFinder'
-export { peerIdFromPeerDescriptor, keyFromPeerDescriptor, isSamePeerDescriptor } from './helpers/peerIdFromPeerDescriptor'
+export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
 export { IceServer } from './connection/WebRTC/WebRtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'

package/src/helpers/PeerID.ts

@@ -49,13 +49,6 @@ export class PeerID {
         return new PeerID({ stringValue })
     }
 
-    static generateRandom(): PeerID {
-        // generate 160 bit random Uint8array
-        const value = new Uint8Array(20)
-        crypto.randomFillSync(value)
-        return new PeerID({ value })
-    }
-
     // TODO convert to static method?
     // eslint-disable-next-line class-methods-use-this
     private ip2Int(ip: string): number {

package/src/helpers/browser/isBrowserEnvironment.ts

@@ -0,0 +1 @@
+export const isBrowserEnvironment = (): boolean => false

package/src/helpers/browser/isBrowserEnvironment_override.ts

@@ -0,0 +1,3 @@
+// webpack overwrites the isBrowserEnvironment.ts with this file when it creates the browser bundle
+
+export const isBrowserEnvironment = (): boolean => true

package/src/helpers/kademliaId.ts

@@ -0,0 +1,8 @@
+import crypto from 'crypto'
+
+// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
+const KADEMLIA_ID_LENGTH_IN_BYTES = 20
+
+export const createRandomKademliaId = (): Uint8Array => {
+    return crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES)
+}

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -9,6 +9,6 @@ export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey
     return PeerID.fromValue(peerDescriptor.kademliaId).toKey()
 }
 
-export const isSamePeerDescriptor = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
+export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
     return peerIdFromPeerDescriptor(peerDescriptor1).equals(peerIdFromPeerDescriptor(peerDescriptor2))
 }

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -253,10 +253,6 @@ export interface PeerDescriptor {
      * @generated from protobuf field: optional uint32 region = 7;
      */
     region?: number;
-    /**
-     * @generated from protobuf field: optional string nodeName = 8;
-     */
-    nodeName?: string;
 }
 /**
  * @generated from protobuf message dht.ConnectivityMethod
@@ -1019,8 +1015,7 @@ class PeerDescriptor$Type extends MessageType$<PeerDescriptor> {
             { no: 4, name: "tcp", kind: "message", T: () => ConnectivityMethod },
             { no: 5, name: "websocket", kind: "message", T: () => ConnectivityMethod },
             { no: 6, name: "openInternet", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
-            { no: 7, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
-            { no: 8, name: "nodeName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+            { no: 7, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
 }

package/test/benchmark/KademliaCorrectness.test.ts

@@ -1,6 +1,8 @@
 /* eslint-disable no-console */
 import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
+import { PeerID } from '../../src/helpers/PeerID'
+import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
@@ -70,7 +72,7 @@ describe('Kademlia correctness', () => {
                 groundTruthString += groundTruth[i + ''][j].name + ','
             }
 
-            const kademliaNeighbors = nodes[i].getNeighborList().getContactIds()
+            const kademliaNeighbors = nodes[i].getClosestContacts().map((p) => PeerID.fromValue(p.kademliaId))
 
             let kadString = 'kademliaNeighbors: '
             kademliaNeighbors.forEach((neighbor) => {
@@ -86,7 +88,8 @@ describe('Kademlia correctness', () => {
                     correctNeighbors++
                 }
             } catch (e) {
-                console.error('Node ' + nodes[i].getPeerDescriptor().nodeName + ' had only ' + kademliaNeighbors.length + ' kademlia neighbors')
+                console.error('Node ' + keyFromPeerDescriptor(nodes[i].getPeerDescriptor()) + ' had only ' 
+                    + kademliaNeighbors.length + ' kademlia neighbors')
             }
             if (correctNeighbors === 0) {
                 console.log('No correct neighbors found for node ' + i)

package/test/benchmark/RecursiveFind.test.ts

@@ -5,7 +5,8 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { PeerID, peerIdFromPeerDescriptor } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
 
@@ -31,19 +32,18 @@ describe('Recursive find correctness', () => {
 
         nodes = []
         const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined, entryPointId)
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, Uint8Array.from(dhtIds[0].data), undefined)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
 
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
 
-            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined, nodeId)
+            const node = await createMockConnectionDhtNode(nodeId, simulator, Uint8Array.from(dhtIds[i].data), undefined)
             nodeIndicesById[node.getNodeId().toKey()] = i
             nodes.push(node)
         }
@@ -70,7 +70,7 @@ describe('Recursive find correctness', () => {
         debugVars['waiting'] = false
         logger.info('waiting over')
 
-        nodes.forEach((node) => logger.info(node.getPeerDescriptor().nodeName + ': connections:' +
+        nodes.forEach((node) => logger.info(keyFromPeerDescriptor(node.getPeerDescriptor()) + ': connections:' +
             node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
             + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
             + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()

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

@@ -1,6 +1,6 @@
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('Layer0-Layer1', () => {
     const epPeerDescriptor: PeerDescriptor = {
@@ -35,11 +35,11 @@ describe('Layer0-Layer1', () => {
         await node1.start()
         await node2.start()
 
-        stream1Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID1 })
-        stream1Node2 = new DhtNode({ transportLayer: node1, serviceId: STREAM_ID1 })
+        stream1Node1 = new DhtNode({ transport: epDhtNode, serviceId: STREAM_ID1 })
+        stream1Node2 = new DhtNode({ transport: node1, serviceId: STREAM_ID1 })
 
-        stream2Node1 = new DhtNode({ transportLayer: epDhtNode, serviceId: STREAM_ID2 })
-        stream2Node2 = new DhtNode({ transportLayer: node2, serviceId: STREAM_ID2 })
+        stream2Node1 = new DhtNode({ transport: epDhtNode, serviceId: STREAM_ID2 })
+        stream2Node2 = new DhtNode({ transport: node2, serviceId: STREAM_ID2 })
 
         await Promise.all([
             stream1Node1.start(),
@@ -76,14 +76,14 @@ describe('Layer0-Layer1', () => {
             stream2Node1.joinDht([epPeerDescriptor]),
             stream2Node2.joinDht([epPeerDescriptor])
         ])
-        expect(stream1Node1.getNeighborList().getSize()).toEqual(1)
-        expect(stream1Node2.getNeighborList().getSize()).toEqual(1)
-        expect(stream2Node1.getNeighborList().getSize()).toEqual(1)
-        expect(stream2Node2.getNeighborList().getSize()).toEqual(1)
-
-        expect(stream1Node1.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(node1.getPeerDescriptor()))).toEqual(true)
-        expect(stream1Node2.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(epPeerDescriptor))).toEqual(true)
-        expect(stream2Node1.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(node2.getPeerDescriptor()))).toEqual(true)
-        expect(stream2Node2.getNeighborList().getContactIds()[0].equals(peerIdFromPeerDescriptor(epPeerDescriptor))).toEqual(true)
+        expect(stream1Node1.getClosestContacts()).toHaveLength(1)
+        expect(stream1Node2.getClosestContacts()).toHaveLength(1)
+        expect(stream2Node1.getClosestContacts()).toHaveLength(1)
+        expect(stream2Node2.getClosestContacts()).toHaveLength(1)
+
+        expect(areEqualPeerDescriptors(stream1Node1.getClosestContacts()[0], node1.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream1Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node1.getClosestContacts()[0], node2.getPeerDescriptor())).toBe(true)
+        expect(areEqualPeerDescriptors(stream2Node2.getClosestContacts()[0], epPeerDescriptor)).toBe(true)
     })
 })

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

@@ -54,31 +54,31 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer1EntryPoint = new DhtNode({
             peerId: binaryToHex(entrypointDescriptor.kademliaId),
-            transportLayer: layer0EntryPoint,
+            transport: layer0EntryPoint,
             serviceId: 'layer1'
         })
 
         layer1Node1 = new DhtNode({
             peerId: layer0Node1Id,
-            transportLayer: layer0Node1,
+            transport: layer0Node1,
             serviceId: 'layer1'
         })
 
         layer1Node2 = new DhtNode({
             peerId: layer0Node2Id,
-            transportLayer: layer0Node2,
+            transport: layer0Node2,
             serviceId: 'layer1'
         })
 
         layer1Node3 = new DhtNode({
             peerId: layer0Node3Id,
-            transportLayer: layer0Node3,
+            transport: layer0Node3,
             serviceId: 'layer1'
         })
 
         layer1Node4 = new DhtNode({
             peerId: layer0Node4Id,
-            transportLayer: layer0Node4,
+            transport: layer0Node4,
             serviceId: 'layer1'
         })
 

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

@@ -8,7 +8,6 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 describe('Layer0 with WebRTC connections', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('entrypoint').value,
-        nodeName: 'entrypoint',
         type: NodeType.NODEJS,
         websocket: { host: '127.0.0.1', port: 10029, tls: false }
     }
@@ -20,15 +19,15 @@ describe('Layer0 with WebRTC connections', () => {
 
     beforeEach(async () => {
 
-        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, nodeName: 'entrypoint', numberOfNodesPerKBucket: 8 })
+        epDhtNode = new DhtNode({ peerDescriptor: epPeerDescriptor, numberOfNodesPerKBucket: 8 })
         await epDhtNode.start()
 
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ nodeName: 'Peer0', entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ nodeName: 'Peer1', entryPoints: [epPeerDescriptor] })
-        node3 = new DhtNode({ nodeName: 'Peer2', entryPoints: [epPeerDescriptor] })
-        node4 = new DhtNode({ nodeName: 'Peer3', entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node3 = new DhtNode({ entryPoints: [epPeerDescriptor] })
+        node4 = new DhtNode({ entryPoints: [epPeerDescriptor] })
 
         await Promise.all([
             node1.start(),

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

@@ -2,12 +2,13 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 
+const NUM_OF_NODES_PER_KBUCKET = 8
+
 describe('Layer1 Scale', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('0').value,
         type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43228, tls: false },
-        nodeName: 'entrypoint'
+        websocket: { host: '127.0.0.1', port: 43228, tls: false }
     }
 
     const STREAM_ID = 'stream'
@@ -26,7 +27,7 @@ describe('Layer1 Scale', () => {
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
-        epLayer1Node = new DhtNode({ transportLayer: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
+        epLayer1Node = new DhtNode({ transport: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
         await epLayer1Node.start()
         await epLayer1Node.joinDht([epPeerDescriptor])
 
@@ -34,15 +35,19 @@ describe('Layer1 Scale', () => {
         layer1Nodes = []
 
         for (let i = 1; i < NUM_OF_NODES; i++) {
-            const node = new DhtNode({ nodeName: `${i}`, entryPoints: [epPeerDescriptor] })
+            const node = new DhtNode({ 
+                entryPoints: [epPeerDescriptor],
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
+            })
             await node.start()
             layer0Nodes.push(node)
             const layer1 = new DhtNode({
-                transportLayer: node,
+                transport: node,
                 entryPoints: [epPeerDescriptor],
                 peerDescriptor: node.getPeerDescriptor(),
                 serviceId: STREAM_ID,
-                rpcRequestTimeout: 5000
+                rpcRequestTimeout: 5000,
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
             await layer1.start()
             layer1Nodes.push(layer1)
@@ -60,10 +65,10 @@ describe('Layer1 Scale', () => {
 
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 1)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() / 2)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -2,12 +2,13 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 
+const NUM_OF_NODES_PER_KBUCKET = 8
+
 describe('Layer1 Scale', () => {
     const epPeerDescriptor: PeerDescriptor = {
         kademliaId: PeerID.fromString('entrypoint').value,
         type: NodeType.NODEJS,
-        websocket: { host: '127.0.0.1', port: 43225, tls: false },
-        nodeName: 'entrypoint'
+        websocket: { host: '127.0.0.1', port: 43225, tls: false }
     }
 
     const STREAM_ID = 'stream'
@@ -24,11 +25,11 @@ describe('Layer1 Scale', () => {
     const websocketPortRange = { min: 62200, max: 62200 + NUM_OF_NODES }
 
     beforeEach(async () => {
-        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor, nodeName: 'entrypoint' })
+        epLayer0Node = new DhtNode({ peerDescriptor: epPeerDescriptor })
         await epLayer0Node.start()
         await epLayer0Node.joinDht([epPeerDescriptor])
 
-        epLayer1Node = new DhtNode({ transportLayer: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID, nodeName: 'entrypoint' })
+        epLayer1Node = new DhtNode({ transport: epLayer0Node, peerDescriptor: epPeerDescriptor, serviceId: STREAM_ID })
         await epLayer1Node.start()
         await epLayer1Node.joinDht([epPeerDescriptor])
 
@@ -36,15 +37,19 @@ describe('Layer1 Scale', () => {
         layer1Nodes = []
 
         for (let i = 0; i < NUM_OF_NODES; i++) {
-            const node = new DhtNode({ nodeName: `${i}`, websocketPortRange, entryPoints: [epPeerDescriptor] })
+            const node = new DhtNode({ 
+                websocketPortRange, 
+                entryPoints: [epPeerDescriptor],
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
+            })
             await node.start()
             layer0Nodes.push(node)
             const layer1 = new DhtNode({
-                nodeName: `${i}`,
-                transportLayer: node,
+                transport: node,
                 entryPoints: [epPeerDescriptor],
                 peerDescriptor: node.getPeerDescriptor(),
-                serviceId: STREAM_ID
+                serviceId: STREAM_ID,
+                numberOfNodesPerKBucket: NUM_OF_NODES_PER_KBUCKET
             })
             await layer1.start()
             layer1Nodes.push(layer1)
@@ -66,10 +71,10 @@ describe('Layer1 Scale', () => {
     // TODO: fix flaky test in NET-1021
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() - 1)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node ) => {
-            expect(node.getBucketSize()).toBeGreaterThanOrEqual(node.getK() / 2)
+            expect(node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

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

@@ -3,7 +3,7 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { PeerID } from '../../src/helpers/PeerID'
 import { waitForCondition } from '@streamr/utils'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('WebSocket IConnection Requests', () => {
     const epPeerDescriptor: PeerDescriptor = {
@@ -22,8 +22,8 @@ describe('WebSocket IConnection Requests', () => {
 
         await epDhtNode.joinDht([epPeerDescriptor])
 
-        node1 = new DhtNode({ nodeName: 'node1', websocketPortRange: { min: 10022, max: 10022 }, entryPoints: [epPeerDescriptor] })
-        node2 = new DhtNode({ nodeName: 'node2', entryPoints: [epPeerDescriptor] })
+        node1 = new DhtNode({ websocketPortRange: { min: 10022, max: 10022 }, entryPoints: [epPeerDescriptor] })
+        node2 = new DhtNode({ entryPoints: [epPeerDescriptor] })
         await node1.start()
         await node2.start()
     })
@@ -40,12 +40,12 @@ describe('WebSocket IConnection Requests', () => {
         let connected2 = false
 
         node1.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (isSamePeerDescriptor(peerDescriptor, node2.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node2.getPeerDescriptor())) {
                 connected1 = true
             }
         })
         node2.on('connected', (peerDescriptor: PeerDescriptor) => {
-            if (isSamePeerDescriptor(peerDescriptor, node1.getPeerDescriptor())) {
+            if (areEqualPeerDescriptors(peerDescriptor, node1.getPeerDescriptor())) {
                 connected2 = true
             }
         })

package/test/integration/ConnectionLocking.test.ts

@@ -1,20 +1,30 @@
-import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { waitForCondition } from '@streamr/utils'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { Simulator } from '../../src/connection/Simulator/Simulator'
+import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { ITransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
-import { SimulatorTransport } from '../../src/exports'
+import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            transport,
+            createOwnPeerDescriptor: () => ownPeerDescriptor
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 describe('Connection Locking', () => {
 
     const mockPeerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('mock1').value,
-        nodeName: 'mock1',
         type: NodeType.NODEJS
     }
     const mockPeerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('mock2').value,
-        nodeName: 'mock2',
         type: NodeType.NODEJS
     }
 
@@ -29,17 +39,13 @@ describe('Connection Locking', () => {
     beforeEach(async () => {
         simulator = new Simulator()
         mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
+        await mockConnectorTransport1.start()
         mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
-
-        connectionManager1 = new ConnectionManager({
-            transportLayer: mockConnectorTransport1
-        })
-
-        connectionManager2 = new ConnectionManager({
-            transportLayer: mockConnectorTransport2
-        })
-        await connectionManager1.start(() => mockPeerDescriptor1)
-        await connectionManager2.start(() => mockPeerDescriptor2)
+        await mockConnectorTransport2.start()
+        connectionManager1 = createConnectionManager(mockPeerDescriptor1, mockConnectorTransport1)
+        connectionManager2 = createConnectionManager(mockPeerDescriptor2, mockConnectorTransport2)
+        await connectionManager1.start()
+        await connectionManager2.start()
     })
 
     afterEach(async () => {
@@ -68,7 +74,7 @@ describe('Connection Locking', () => {
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock2')),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
         expect(connectionManager1.hasConnection(mockPeerDescriptor2)).toEqual(true)
@@ -97,7 +103,7 @@ describe('Connection Locking', () => {
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock2')),
+            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
 
@@ -125,10 +131,10 @@ describe('Connection Locking', () => {
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
         await waitForCondition(() =>
-            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2, 'testLock1')
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2, 'testLock1')
-            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock1')
-            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1, 'testLock1')
+            connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
+            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
+            && !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
+            && connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
         )
         
         expect(connectionManager2.hasConnection(mockPeerDescriptor1)).toEqual(true)
@@ -150,12 +156,12 @@ describe('Connection Locking', () => {
         await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
         
         await waitForCondition(() =>
-            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2, 'testLock1')
-            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2, 'testLock1')
+            !connectionManager1.hasRemoteLockedConnection(mockPeerDescriptor2)
+            && !connectionManager1.hasLocalLockedConnection(mockPeerDescriptor2)
         )
         await waitForCondition(() =>
-            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1, 'testLock1')
-            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1, 'testLock1')
+            !connectionManager2.hasRemoteLockedConnection(mockPeerDescriptor1)
+            && !connectionManager2.hasLocalLockedConnection(mockPeerDescriptor1)
         )
         await waitForCondition(() => !connectionManager2.hasConnection(mockPeerDescriptor1))
         await waitForCondition(() => !connectionManager1.hasConnection(mockPeerDescriptor2))