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

package/test/integration/ConnectionManager.test.ts

@@ -1,10 +1,12 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { ConnectivityResponse, Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../src/helpers/PeerID'
 import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { createPeerDescriptor } from '../../src/dht/DhtNode'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger } from '@streamr/utils'
+import { Logger, MetricsContext } from '@streamr/utils'
+import { SimulatorTransport } from '../../src/exports'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 
 const logger = new Logger(module)
 
@@ -14,30 +16,48 @@ describe('ConnectionManager', () => {
 
     const mockPeerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('tester1').value,
-        nodeName: 'tester1',
         type: NodeType.NODEJS
     }
     const mockPeerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('tester2').value,
-        nodeName: 'tester2',
         type: NodeType.NODEJS
     }
 
     const mockPeerDescriptor3: PeerDescriptor = {
         kademliaId: PeerID.fromString('tester3').value,
-        nodeName: 'tester3',
         type: NodeType.NODEJS
     }
     const mockPeerDescriptor4: PeerDescriptor = {
         kademliaId: PeerID.fromString('tester4').value,
-        nodeName: 'tester4',
         type: NodeType.NODEJS
     }
     const simulator = new Simulator()
 
-    const mockTransport = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor1, simulator: simulator })
-    const mockConnectorTransport1 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor1, simulator })
-    const mockConnectorTransport2 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor2, simulator })
+    const mockTransport = new SimulatorTransport(mockPeerDescriptor1, simulator)
+    const mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
+    const mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)
+
+    let createOwnPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
+
+    const createConnectionManager = (opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+        return new ConnectionManager({
+            createConnectorFacade: () => new DefaultConnectorFacade({
+                createOwnPeerDescriptor,
+                ...opts
+            }),
+            metricsContext: new MetricsContext()
+        })
+    }
+
+    beforeEach(() => {
+        createOwnPeerDescriptor = jest.fn().mockImplementation((response) => createPeerDescriptor(response))
+    })
+
+    beforeAll(async () => {
+        await mockTransport.start()
+        await mockConnectorTransport1.start()
+        await mockConnectorTransport2.start()
+    })
 
     afterAll(async ()=> {
         await mockTransport.stop()
@@ -46,100 +66,84 @@ describe('ConnectionManager', () => {
     })
 
     it('Can start alone', async () => {
-        const connectionManager = new ConnectionManager({
-            transportLayer: mockTransport,
+
+        const connectionManager = createConnectionManager({
+            transport: mockTransport,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 9991, max: 9991 }
+            websocketPortRange: { min: 9991, max: 9991 },
         })
 
-        await connectionManager.start((report) => {
-            expect(report.host).toEqual('127.0.0.1')
-            expect(report.openInternet).toEqual(true)
-            return createPeerDescriptor(report)
-        })
+        await connectionManager.start()
+        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
 
         await connectionManager.stop()
     })
 
     it('Throws an async exception if fails to connect to entrypoints', async () => {
 
-        const connectionManager = new ConnectionManager({
-            transportLayer: mockTransport,
+        const connectionManager = createConnectionManager({
+            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 } }
             ]
         })
 
-        await expect(connectionManager.start((report) => {
-            return createPeerDescriptor(report)
-        })).rejects.toThrow('Failed to connect to the entrypoints')
+        await expect(connectionManager.start()).rejects.toThrow('Failed to connect to the entrypoints')
 
         await connectionManager.stop()
     }, 15000)
 
     it('Can probe connectivity in open internet', async () => {
-        const connectionManager1 = new ConnectionManager({
-            transportLayer: mockTransport,
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 9993, max: 9993 }
         })
 
-        await connectionManager1.start((report) => {
-            expect(report.host).toEqual('127.0.0.1')
-            expect(report.openInternet).toEqual(true)
-            return createPeerDescriptor(report)
-        })
+        await connectionManager1.start()
+        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
 
-        const connectionManager2 = new ConnectionManager({
-            transportLayer: mockConnectorTransport2,
+        const connectionManager2 = createConnectionManager({
+            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 } }
             ]
         })
 
-        await connectionManager2.start((report) => {
-            expect(report.host).toEqual('127.0.0.1')
-            expect(report.openInternet).toEqual(true)
-            return createPeerDescriptor(report)
-        })
+        await connectionManager2.start()
+        expect(createOwnPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[1][0].openInternet).toEqual(true)
 
         await connectionManager1.stop()
         await connectionManager2.stop()
     })
 
     it('Can send data to other connectionmanager over websocket', async () => {
-        const connectionManager1 = new ConnectionManager({
-            transportLayer: mockConnectorTransport1,
+        const connectionManager1 = createConnectionManager({
+            transport: mockConnectorTransport1,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 9995, max: 9995 }
         })
 
-        let peerDescriptor: PeerDescriptor | undefined
+        await connectionManager1.start()
+        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
 
-        await connectionManager1.start((report) => {
-            expect(report.host).toEqual('127.0.0.1')
-            expect(report.openInternet).toEqual(true)
-            peerDescriptor = createPeerDescriptor(report)
-            return peerDescriptor
-        })
-
-        const connectionManager2 = new ConnectionManager({
-            transportLayer: mockConnectorTransport2,
+        const connectionManager2 = createConnectionManager({
+            transport: mockConnectorTransport2,
             websocketPortRange: { min: 9996, max: 9996 },
             entryPoints: [
-                peerDescriptor!
+                connectionManager1.getPeerDescriptor()
             ]
         })
 
-        let peerDescriptor2: PeerDescriptor | undefined
-        await connectionManager2.start((report2) => {
-            expect(report2.host).toEqual('127.0.0.1')
-            expect(report2.openInternet).toEqual(true)
-            peerDescriptor2 = createPeerDescriptor(report2)
-            return peerDescriptor2
-        })
+        await connectionManager2.start()
+        expect(createOwnPeerDescriptor.mock.calls[1][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[1][0].openInternet).toEqual(true)
 
         const msg: Message = {
             serviceId,
@@ -159,18 +163,18 @@ describe('ConnectionManager', () => {
         })
 
         const connectedPromise1 = new Promise<void>((resolve, _reject) => {
-            connectionManager1.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager1.on('connected', () => {
                 resolve()
             })
         })
 
         const connectedPromise2 = new Promise<void>((resolve, _reject) => {
-            connectionManager2.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager2.on('connected', () => {
                 resolve()
             })
         })
 
-        msg.targetDescriptor = peerDescriptor2
+        msg.targetDescriptor = connectionManager2.getPeerDescriptor()
         connectionManager1.send(msg)
 
         await Promise.all([promise, connectedPromise1, connectedPromise2])
@@ -180,33 +184,25 @@ describe('ConnectionManager', () => {
     })
 
     it('Can disconnect websockets', async () => {
-        const connectionManager1 = new ConnectionManager({ 
-            transportLayer: mockConnectorTransport1,
+        const connectionManager1 = createConnectionManager({ 
+            transport: mockConnectorTransport1,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 9997, max: 9997 }
         })
 
-        let peerDescriptor: PeerDescriptor | undefined
-        await connectionManager1.start((report) => {
-            expect(report.host).toEqual('127.0.0.1')
-            expect(report.openInternet).toEqual(true)
-            peerDescriptor = createPeerDescriptor(report)
-            return peerDescriptor
-        })
+        await connectionManager1.start()
+        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
 
-        const connectionManager2 = new ConnectionManager({
-            transportLayer: mockConnectorTransport2,
+        const connectionManager2 = createConnectionManager({
+            transport: mockConnectorTransport2,
             websocketPortRange: { min: 9999, max: 9999 },
             entryPoints: [
-                peerDescriptor!
+                connectionManager1.getPeerDescriptor()
             ]
         })
 
-        let peerDescriptor2: PeerDescriptor | undefined
-        await connectionManager2.start((report2) => {
-            peerDescriptor2 = createPeerDescriptor(report2)
-            return peerDescriptor2
-        })
+        await connectionManager2.start()
 
         const msg: Message = {
             serviceId,
@@ -219,14 +215,14 @@ describe('ConnectionManager', () => {
         }
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            connectionManager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager1.on('disconnected', () => {
                 logger.info('disconnectedPromise1')
                 resolve()
             })
         })
 
         const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
-            connectionManager2.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager2.on('disconnected', () => {
                 logger.info('disconnectedPromise2')
                 resolve()
             })
@@ -238,13 +234,13 @@ describe('ConnectionManager', () => {
                 resolve()
             })
         })
-        msg.targetDescriptor = peerDescriptor2
+        msg.targetDescriptor = connectionManager2.getPeerDescriptor()
         connectionManager1.send(msg)
 
         await promise
 
         // @ts-expect-error private field
-        connectionManager1.closeConnection(peerDescriptor2)
+        connectionManager1.closeConnection(connectionManager2.getPeerDescriptor())
 
         await Promise.all([disconnectedPromise1, disconnectedPromise2])
 
@@ -254,8 +250,10 @@ describe('ConnectionManager', () => {
 
     it('Connects and disconnects over simulated connections', async () => {
         const simulator2 = new Simulator()
-        const connectionManager3 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor3, simulator: simulator2 })
-        const connectionManager4 = new ConnectionManager({ ownPeerDescriptor: mockPeerDescriptor4, simulator: simulator2 })
+        const connectionManager3 = new SimulatorTransport(mockPeerDescriptor3, simulator2)
+        await connectionManager3.start()
+        const connectionManager4 = new SimulatorTransport(mockPeerDescriptor4, simulator2)
+        await connectionManager4.start()
 
         const msg: Message = {
             serviceId,
@@ -275,25 +273,25 @@ describe('ConnectionManager', () => {
         })
 
         const connectedPromise1 = new Promise<void>((resolve, _reject) => {
-            connectionManager4.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager4.on('connected', () => {
                 resolve()
             })
         })
 
         const connectedPromise2 = new Promise<void>((resolve, _reject) => {
-            connectionManager3.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager3.on('connected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            connectionManager4.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager4.on('disconnected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
-            connectionManager3.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            connectionManager3.on('disconnected', () => {
                 resolve()
             })
         })
@@ -310,17 +308,16 @@ describe('ConnectionManager', () => {
     })
 
     it('Cannot send to own WebSocketServer if kademliaIds do not match', async () => {
-        const connectionManager1 = new ConnectionManager({
-            transportLayer: mockTransport,
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
             websocketHost: '127.0.0.1',
             websocketPortRange: { min: 10001, max: 10001 }
         })
 
-        await connectionManager1.start((report) => {
-            expect(report.host).toEqual('127.0.0.1')
-            expect(report.openInternet).toEqual(true)
-            return createPeerDescriptor(report)
-        })
+        await connectionManager1.start()
+        expect(createOwnPeerDescriptor.mock.calls[0][0].host).toEqual('127.0.0.1')
+        expect(createOwnPeerDescriptor.mock.calls[0][0].openInternet).toEqual(true)
+        
         const peerDescriptor = connectionManager1.getPeerDescriptor()
         peerDescriptor.kademliaId = new Uint8Array([12, 12, 12, 12])
         const msg: Message = {

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -0,0 +1,53 @@
+import { LatencyType, Simulator } from '../../src/connection/Simulator/Simulator'
+import { getRandomRegion } from '../../src/connection/Simulator/pings'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode } from '../utils/utils'
+
+const NUM_OF_NODES_PER_KBUCKET = 8
+
+const runTest = async (latencyType: LatencyType) => {
+    const simulator = new Simulator(latencyType)
+    const entryPointId = '0'
+    const entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
+    const entrypointDescriptor = {
+        kademliaId: entryPoint.getNodeId().value,
+        type: NodeType.NODEJS,
+        region: getRandomRegion()
+    }
+    const nodes: DhtNode[] = []
+    for (let i = 1; i < 100; i++) {
+        const nodeId = `${i}`
+        const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, NUM_OF_NODES_PER_KBUCKET)
+        nodes.push(node)
+    }
+
+    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.getClosestContacts().length).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+    })
+    expect(entryPoint.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+
+    await Promise.all([
+        entryPoint.stop(),
+        ...nodes.map((node) => node.stop())
+    ])
+    simulator.stop()
+}
+
+describe('DhtJoinPeerDiscovery', () => {
+    
+    it('latency: none', async () => {
+        await runTest(LatencyType.NONE)
+    }, 60 * 1000)
+
+    it('latency: random', async () => {
+        await runTest(LatencyType.RANDOM)
+    }, 60 * 1000)
+
+    it('latency: real', async () => {
+        await runTest(LatencyType.REAL)
+    }, 60 * 1000)
+})

package/test/integration/DhtRpc.test.ts

@@ -4,8 +4,6 @@ import { DhtRpcServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.
 import { generateId } from '../utils/utils'
 import { ClosestPeersRequest, ClosestPeersResponse, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { wait } from '@streamr/utils'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('DhtRpc', () => {
@@ -24,7 +22,7 @@ describe('DhtRpc', () => {
         type: NodeType.NODEJS
     }
 
-    const outgoingListener2 = (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+    const outgoingListener2 = (message: RpcMessage) => {
         rpcCommunicator1.handleIncomingMessage(message)
     }
 
@@ -35,7 +33,7 @@ describe('DhtRpc', () => {
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', MockDhtRpc.getClosestPeers)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
@@ -74,7 +72,7 @@ describe('DhtRpc', () => {
 
     it('Default RPC timeout, client side', async () => {
         rpcCommunicator2.off('outgoingMessage', outgoingListener2)
-        rpcCommunicator2.on('outgoingMessage', async (_message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', async () => {
             await wait(3000)
         })
         const response2 = client2.getClosestPeers(
@@ -92,7 +90,7 @@ describe('DhtRpc', () => {
     it('Server side timeout', async () => {
         let timeout: NodeJS.Timeout
 
-        async function respondGetClosestPeersWithTimeout(_request: ClosestPeersRequest, _context: ServerCallContext): Promise<ClosestPeersResponse> {
+        async function respondGetClosestPeersWithTimeout(): Promise<ClosestPeersResponse> {
             const neighbors = getMockPeers()
             const response: ClosestPeersResponse = {
                 peers: neighbors,

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

@@ -3,7 +3,9 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
 import { UUID } from '../../src/helpers/UUID'
-import { NodeType } from '../../src/exports'
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+
+const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1', () => {
 
@@ -12,8 +14,7 @@ describe('Layer1', () => {
 
     const entryPoint0Descriptor = {
         kademliaId: PeerID.fromString(layer0EntryPointId).value,
-        type: NodeType.NODEJS,
-        nodeName: layer0EntryPointId
+        type: NodeType.NODEJS
     }
 
     let layer0EntryPoint: DhtNode
@@ -38,7 +39,6 @@ describe('Layer1', () => {
                 undefined,
                 undefined,
                 undefined,
-                undefined,
                 60000
             )
             nodes.push(node)
@@ -63,7 +63,7 @@ describe('Layer1', () => {
         const layer1Nodes: DhtNode[] = []
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0 = nodes[i]
-            const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0)
+            const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, undefined, NUM_OF_NODES_PER_KBUCKET)
             layer1Nodes.push(layer1)
             layer1CleanUp.push(layer1)
         }
@@ -75,7 +75,7 @@ describe('Layer1', () => {
             const layer1Node = layer1Nodes[i]
             expect(layer1Node.getNodeId().equals(layer0Node.getNodeId())).toEqual(true)
             expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
-            expect(layer1Node.getBucketSize()).toBeGreaterThanOrEqual(layer1Node.getK() / 2)
+            expect(layer1Node.getBucketSize()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
             expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
         }
     }, 120000)
@@ -163,8 +163,8 @@ describe('Layer1', () => {
     //
     //     await Promise.all(layer1Nodes.map((node) => node.joinDht(entryPoint0Descriptor)))
     //
-    //     layer1Nodes.map((sender) => {
-    //         layer1Nodes.map(async (receiver) => {
+    //     layer1Nodes.forEach((sender) => {
+    //         layer1Nodes.forEach(async (receiver) => {
     //             if (!sender.getNodeId().equals(receiver.getNodeId())) {
     //                 const rpcWrapper = createWrappedClosestPeersRequest(sender.getPeerDescriptor(), receiver.getPeerDescriptor())
     //                 const message: Message = {

package/test/integration/MigrateData.test.ts

@@ -6,7 +6,8 @@ import { createMockConnectionDhtNode, waitNodesReadyForTesting } from '../utils/
 import { execSync } from 'child_process'
 import fs from 'fs'
 import { Logger } from '@streamr/utils'
-import { PeerID } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { Contact } from '../../src/dht/contact/Contact'
@@ -41,14 +42,13 @@ describe('Migrating data from node to node in DHT', () => {
         nodes = []
         const entryPointId = '0'
         entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
-            Uint8Array.from(dhtIds[0].data), K, entryPointId, MAX_CONNECTIONS)
+            Uint8Array.from(dhtIds[0].data), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodesById.set(entryPoint.getNodeId().toKey(), entryPoint)
 
         entrypointDescriptor = {
             kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: entryPointId
+            type: NodeType.NODEJS
         }
 
         nodes.push(entryPoint)
@@ -57,7 +57,7 @@ describe('Migrating data from node to node in DHT', () => {
             const nodeId = `${i}`
 
             const node = await createMockConnectionDhtNode(nodeId, simulator,
-                Uint8Array.from(dhtIds[i].data), K, nodeId, MAX_CONNECTIONS)
+                Uint8Array.from(dhtIds[i].data), K, MAX_CONNECTIONS)
             nodesById.set(node.getNodeId().toKey(), node)
             nodes.push(node)
         }
@@ -91,7 +91,7 @@ describe('Migrating data from node to node in DHT', () => {
 
         logger.info('Nodes sorted according to distance to data are: ')
         closest.forEach((contact) => {
-            logger.info('' + contact.getPeerDescriptor().nodeName)
+            logger.info(keyFromPeerDescriptor(contact.getPeerDescriptor()))
         })
 
         logger.info('node 0 joining to the DHT')
@@ -114,13 +114,13 @@ describe('Migrating data from node to node in DHT', () => {
                 hasDataMarker = '<-'
             }
 
-            logger.info(contact.getPeerDescriptor().nodeName + ' ' + node.getPeerDescriptor().nodeName + hasDataMarker)
+            logger.info(keyFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + keyFromPeerDescriptor(node.getPeerDescriptor()) + hasDataMarker)
         })
 
         logger.info(NUM_NODES + ' nodes joining layer0 DHT')
         await Promise.all(
             nodes.map((node) => {
-                if (node.getPeerDescriptor().nodeName != '0') {
+                if (keyFromPeerDescriptor(node.getPeerDescriptor()) != '0') {
                     node.joinDht([entrypointDescriptor])
                 }
             })
@@ -142,7 +142,7 @@ describe('Migrating data from node to node in DHT', () => {
                 hasDataMarker = '<-'
             }
 
-            logger.info('' + node.getPeerDescriptor().nodeName + hasDataMarker)
+            logger.info(keyFromPeerDescriptor(node.getPeerDescriptor()) + hasDataMarker)
         })
 
         const closestNode = nodesById.get(PeerID.fromValue(closest[0].getPeerDescriptor().kademliaId).toKey())!

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

@@ -52,8 +52,7 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         entryPointDescriptor = {
             kademliaId: layer0EntryPoint.getNodeId().value,
-            type: NodeType.NODEJS,
-            nodeName: layer0EntryPointId
+            type: NodeType.NODEJS
         }
 
         await layer0EntryPoint.joinDht([entryPointDescriptor])

package/test/integration/RecursiveFind.test.ts

@@ -2,7 +2,8 @@ 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 { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { PeerID, peerIdFromPeerDescriptor } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
+import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 describe('Recursive find correctness', () => {
 
@@ -16,16 +17,15 @@ describe('Recursive find correctness', () => {
     beforeEach(async () => {
         nodes = []
         const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K, entryPointId)
+        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K)
         nodes.push(entryPoint)
         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, undefined, K, nodeId, 20, 60000)
+            const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, 20, 60000)
             nodes.push(node)
         }
         await entryPoint.joinDht([entrypointDescriptor])