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

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

@@ -1,32 +1,22 @@
 import { Simulator } from '../../src/connection/simulator/Simulator'
-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/proto/packages/dht/protos/DhtRpc'
+import { createMockConnectionDhtNode, createMockConnectionLayer1Node, createMockPeerDescriptor } from '../utils/utils'
+import { areEqualNodeIds } from '../../src/helpers/nodeId'
 
+const NODE_COUNT = 48
 const NUM_OF_NODES_PER_KBUCKET = 8
 
 describe('Layer1', () => {
 
     let simulator: Simulator
-    const layer0EntryPointId = new UUID().toString()
-
-    const entryPoint0Descriptor = {
-        nodeId: PeerID.fromString(layer0EntryPointId).value,
-        type: NodeType.NODEJS
-    }
-
+    const entryPoint0Descriptor = createMockPeerDescriptor()
     let layer0EntryPoint: DhtNode
-
-    const NODE_COUNT = 48
     let nodes: DhtNode[]
-
     let layer1CleanUp: DhtNode[]
 
     beforeEach(async () => {
         simulator = new Simulator()
-        layer0EntryPoint = await createMockConnectionDhtNode(layer0EntryPointId, simulator)
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, entryPoint0Descriptor.nodeId)
         await layer0EntryPoint.joinDht([entryPoint0Descriptor])
 
         nodes = []
@@ -34,7 +24,6 @@ describe('Layer1', () => {
 
         for (let i = 0; i < NODE_COUNT; i++) {
             const node = await createMockConnectionDhtNode(
-                new UUID().toString(),
                 simulator,
                 undefined,
                 undefined,
@@ -56,14 +45,14 @@ describe('Layer1', () => {
     })
 
     it('single layer1 dht', async () => {
-        const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint)
+        const layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
         await layer1EntryPoint.joinDht([entryPoint0Descriptor])
         layer1CleanUp.push(layer1EntryPoint)
 
         const layer1Nodes: DhtNode[] = []
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0 = nodes[i]
-            const layer1 = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, undefined, NUM_OF_NODES_PER_KBUCKET)
+            const layer1 = await createMockConnectionLayer1Node(layer0, undefined, NUM_OF_NODES_PER_KBUCKET)
             layer1Nodes.push(layer1)
             layer1CleanUp.push(layer1)
         }
@@ -73,7 +62,7 @@ describe('Layer1', () => {
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0Node = nodes[i]
             const layer1Node = layer1Nodes[i]
-            expect(layer1Node.getNodeId().equals(layer0Node.getNodeId())).toEqual(true)
+            expect(areEqualNodeIds(layer1Node.getNodeId(), layer0Node.getNodeId())).toEqual(true)
             expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
             expect(layer1Node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
             expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())
@@ -81,16 +70,16 @@ describe('Layer1', () => {
     }, 120000)
 
     it('multiple layer1 dht', async () => {
-        const stream1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'one')
+        const stream1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'one')
         await stream1EntryPoint.joinDht([entryPoint0Descriptor])
 
-        const stream2EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'two')
+        const stream2EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'two')
         await stream2EntryPoint.joinDht([entryPoint0Descriptor])
 
-        const stream3EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'three')
+        const stream3EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'three')
         await stream3EntryPoint.joinDht([entryPoint0Descriptor])
 
-        const stream4EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint.getNodeId().toString(), layer0EntryPoint, 'four')
+        const stream4EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint, 'four')
         await stream4EntryPoint.joinDht([entryPoint0Descriptor])
 
         layer1CleanUp.push(stream1EntryPoint)
@@ -105,10 +94,10 @@ describe('Layer1', () => {
 
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0 = nodes[i]
-            const one = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'one')
-            const two = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'two')
-            const three = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'three')
-            const four = await createMockConnectionLayer1Node(layer0.getNodeId().toString(), layer0, 'four')
+            const one = await createMockConnectionLayer1Node(layer0, 'one')
+            const two = await createMockConnectionLayer1Node(layer0, 'two')
+            const three = await createMockConnectionLayer1Node(layer0, 'three')
+            const four = await createMockConnectionLayer1Node(layer0, 'four')
 
             stream1.push(one)
             stream2.push(two)
@@ -180,7 +169,7 @@ describe('Layer1', () => {
     //                 }
     //                 await sender.doRouteMessage({
     //                     message,
-    //                     destinationPeer: receiver.getPeerDescriptor(),
+    //                     target: receiver.getPeerDescriptor().nodeId,
     //                     sourcePeer: sender.getPeerDescriptor(),
     //                     requestId: v4(),
     //                     reachableThrough: [],

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

@@ -1,62 +1,44 @@
 import { Logger } from '@streamr/utils'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
+import { PeerID } from '../../src/exports'
 
 const logger = new Logger(module)
 
+// TODO refactor the test to not to use PeerID
+
 describe('Layer 1 on Layer 0 with mocked connections', () => {
-    const simulator = new Simulator()
-    const layer0EntryPointId = 'layer0entrypoint'
 
+    const simulator = new Simulator()
     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
 
-    let entryPointDescriptor: PeerDescriptor
-
     beforeEach(async () => {
 
-        layer0EntryPoint = await createMockConnectionDhtNode(layer0EntryPointId, simulator)
-
-        const layer0Node1Id = 'node1'
-        layer0Node1 = await createMockConnectionDhtNode(layer0Node1Id, simulator)
-
-        const layer0Node2Id = 'node2'
-        layer0Node2 = await createMockConnectionDhtNode(layer0Node2Id, simulator)
-
-        const layer0Node3Id = 'node3'
-        layer0Node3 = await createMockConnectionDhtNode(layer0Node3Id, simulator)
-
-        const layer0Node4Id = 'node4'
-        layer0Node4 = await createMockConnectionDhtNode(layer0Node4Id, simulator)
-
-        layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPointId, layer0EntryPoint)
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, PeerID.fromString('layer0entrypoint').value)
+        layer0Node1 = await createMockConnectionDhtNode(simulator, PeerID.fromString('node1').value)
+        layer0Node2 = await createMockConnectionDhtNode(simulator, PeerID.fromString('node2').value)
+        layer0Node3 = await createMockConnectionDhtNode(simulator, PeerID.fromString('node3').value)
+        layer0Node4 = await createMockConnectionDhtNode(simulator, PeerID.fromString('node4').value)
 
-        layer1Node1 = await createMockConnectionLayer1Node(layer0Node1Id, layer0Node1)
-        layer1Node2 = await createMockConnectionLayer1Node(layer0Node2Id, layer0Node2)
-        layer1Node3 = await createMockConnectionLayer1Node(layer0Node3Id, layer0Node3)
-        layer1Node4 = await createMockConnectionLayer1Node(layer0Node4Id, layer0Node4)
+        layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
 
-        entryPointDescriptor = {
-            nodeId: layer0EntryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        layer1Node1 = await createMockConnectionLayer1Node(layer0Node1)
+        layer1Node2 = await createMockConnectionLayer1Node(layer0Node2)
+        layer1Node3 = await createMockConnectionLayer1Node(layer0Node3)
+        layer1Node4 = await createMockConnectionLayer1Node(layer0Node4)
 
-        await layer0EntryPoint.joinDht([entryPointDescriptor])
-        await layer1EntryPoint.joinDht([entryPointDescriptor])
+        await layer0EntryPoint.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1EntryPoint.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
     })
 
     afterEach(async () => {
@@ -75,15 +57,15 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
     })
 
     it('Happy Path', async () => {
-        await layer0Node1.joinDht([entryPointDescriptor])
-        await layer0Node2.joinDht([entryPointDescriptor])
-        await layer0Node3.joinDht([entryPointDescriptor])
-        await layer0Node4.joinDht([entryPointDescriptor])
-
-        await layer1Node1.joinDht([entryPointDescriptor])
-        await layer1Node2.joinDht([entryPointDescriptor])
-        await layer1Node3.joinDht([entryPointDescriptor])
-        await layer1Node4.joinDht([entryPointDescriptor])
+        await layer0Node1.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer0Node2.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer0Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer0Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+
+        await layer1Node1.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1Node2.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1Node3.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
+        await layer1Node4.joinDht([layer0EntryPoint.getLocalPeerDescriptor()])
 
         logger.info('layer1EntryPoint.getNumberOfNeighbors() ' + layer1EntryPoint.getNumberOfNeighbors())
         logger.info('layer1Node1.getNumberOfNeighbors()' + layer1Node1.getNumberOfNeighbors())

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -16,9 +16,9 @@ describe('multiple entry point joining', () => {
         beforeEach(async () => {
             simulator = new Simulator(LatencyType.REAL)
 
-            node1 = await createMockConnectionDhtNode('node1', simulator)
-            node2 = await createMockConnectionDhtNode('node2', simulator)
-            node3 = await createMockConnectionDhtNode('node3', simulator)
+            node1 = await createMockConnectionDhtNode(simulator)
+            node2 = await createMockConnectionDhtNode(simulator)
+            node3 = await createMockConnectionDhtNode(simulator)
 
             entryPoints = [
                 node1.getLocalPeerDescriptor(),
@@ -69,11 +69,11 @@ describe('multiple entry point joining', () => {
         beforeEach(async () => {
             simulator = new Simulator(LatencyType.REAL)
             
-            entryPoint1 = await createMockConnectionDhtNode('entryPoint1', simulator)
-            entryPoint2 = await createMockConnectionDhtNode('entryPoint2', simulator)
+            entryPoint1 = await createMockConnectionDhtNode(simulator)
+            entryPoint2 = await createMockConnectionDhtNode(simulator)
             
-            node1 = await createMockConnectionDhtNode('node1', simulator)
-            node2 = await createMockConnectionDhtNode('node2', simulator)
+            node1 = await createMockConnectionDhtNode(simulator)
+            node2 = await createMockConnectionDhtNode(simulator)
 
             entryPoints = [
                 entryPoint1.getLocalPeerDescriptor(),

package/test/integration/ReplicateData.test.ts

@@ -5,27 +5,29 @@ import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dh
 import { createMockConnectionDhtNode, waitNodesReadyForTesting } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { Logger } from '@streamr/utils'
+import { Logger, hexToBinary } from '@streamr/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor, peerIdFromPeerDescriptor } 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'
+import { NodeID } from '../../src/helpers/nodeId'
+import { createMockDataEntry } from '../utils/mock/mockDataEntry'
 
 const logger = new Logger(module)
 
 jest.setTimeout(60000)
 
+const NUM_NODES = 100
+const MAX_CONNECTIONS = 80
+const K = 8
+
 describe('Replicate data from node to node in DHT', () => {
+
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.FIXED, 20)
-    const NUM_NODES = 100
-    const MAX_CONNECTIONS = 80
-    const K = 8
-
-    const nodesById: Map<string, DhtNode> = new Map()
+    const nodesById: Map<NodeID, DhtNode> = new Map()
 
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('ground truth data does not exist yet, generating..')
@@ -40,25 +42,22 @@ describe('Replicate data from node to node in DHT', () => {
     */
     beforeEach(async () => {
         nodes = []
-        const entryPointId = '0'
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator,
+        entryPoint = await createMockConnectionDhtNode(simulator,
             Uint8Array.from(dhtIds[0].data), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
-        nodesById.set(entryPoint.getNodeId().toKey(), entryPoint)
+        nodesById.set(entryPoint.getNodeId(), entryPoint)
 
         entrypointDescriptor = {
-            nodeId: entryPoint.getNodeId().value,
+            nodeId: hexToBinary(entryPoint.getNodeId()),
             type: NodeType.NODEJS
         }
 
         nodes.push(entryPoint)
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-
-            const node = await createMockConnectionDhtNode(nodeId, simulator,
+            const node = await createMockConnectionDhtNode(simulator,
                 Uint8Array.from(dhtIds[i].data), K, MAX_CONNECTIONS)
-            nodesById.set(node.getNodeId().toKey(), node)
+            nodesById.set(node.getNodeId(), node)
             nodes.push(node)
         }
     })
@@ -76,12 +75,12 @@ describe('Replicate data from node to node in DHT', () => {
 
     it('Data replicates to the closest node no matter where it is stored', async () => {
         const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+        const data = createMockDataEntry({ key: dataKey.value })
 
         // calculate offline which node is closest to the data
 
         const sortedList = new SortedContactList<Contact>({ 
-            referenceId: dataKey, 
+            referenceId: dataKey.toNodeId(),
             maxSize: 10000, 
             allowToContainReferenceId: true, 
             emitEvents: false 
@@ -104,18 +103,18 @@ describe('Replicate data from node to node in DHT', () => {
         await nodes[0].joinDht([entrypointDescriptor])
 
         logger.info('storing data to node 0')
-        const successfulStorers = await nodes[0].storeDataToDht(dataKey.value, data)
+        const successfulStorers = await nodes[0].storeDataToDht(dataKey.value, data.data!)
         expect(successfulStorers.length).toBe(1)
         logger.info('data successfully stored to node 0')
 
         logger.info('Nodes sorted according to distance to data with storing nodes marked are: ')
 
         closest.forEach((contact) => {
-            const node = nodesById.get(PeerID.fromValue(contact.getPeerDescriptor().nodeId).toKey())!
+            const node = nodesById.get(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))!
             let hasDataMarker = ''
             
             // @ts-expect-error private field
-            if (node.localDataStore.getEntry(dataKey)) {
+            if (node.localDataStore.getEntries(dataKey.value)) {
                 hasDataMarker = '<-'
             }
 
@@ -139,27 +138,26 @@ describe('Replicate data from node to node in DHT', () => {
         logger.info('After join of 99 nodes: nodes sorted according to distance to data with storing nodes marked are: ')
 
         closest.forEach((contact) => {
-            const node = nodesById.get(PeerID.fromValue(contact.getPeerDescriptor().nodeId).toKey())!
+            const node = nodesById.get(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))!
             let hasDataMarker = ''
 
             // @ts-expect-error private field
-
-            if (node.localDataStore.getEntry(dataKey)) {
+            if (node.localDataStore.getEntries(dataKey.value)) {
                 hasDataMarker = '<-'
             }
 
             logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
         })
 
-        const closestNode = nodesById.get(PeerID.fromValue(closest[0].getPeerDescriptor().nodeId).toKey())!
+        const closestNode = nodesById.get(getNodeIdFromPeerDescriptor(closest[0].getPeerDescriptor()))!
 
         // @ts-expect-error private field
-        expect(closestNode.localDataStore.getEntry(dataKey).size).toBeGreaterThanOrEqual(1)
+        expect(closestNode.localDataStore.getEntries(dataKey.value).size).toBeGreaterThanOrEqual(1)
     }, 180000)
 
     it('Data replicates to the last remaining node if all other nodes leave gracefully', async () => {
         const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
+        const data = createMockDataEntry({ key: dataKey.value })
 
         logger.info(NUM_NODES + ' nodes joining layer0 DHT')
         await Promise.all(
@@ -175,7 +173,7 @@ describe('Replicate data from node to node in DHT', () => {
         const randomIndex = Math.floor(Math.random() * nodes.length)
         logger.info('storing data to a random node: ' + randomIndex)
 
-        const successfulStorers = await nodes[randomIndex].storeDataToDht(dataKey.value, data)
+        const successfulStorers = await nodes[randomIndex].storeDataToDht(dataKey.value, data.data!)
 
         logger.info('data successfully stored to ' + successfulStorers + ' nodes')
 
@@ -192,7 +190,7 @@ describe('Replicate data from node to node in DHT', () => {
 
             logger.info('Stopping node ' + nodeIndex + ' ' +
                 // @ts-expect-error private field
-                (nodes[nodeIndex].localDataStore.getEntry(dataKey) ? ', has data' : ' does not have data'))
+                (nodes[nodeIndex].localDataStore.getEntries(dataKey.value) ? ', has data' : ' does not have data'))
 
             await nodes[nodeIndex].stop()
         }
@@ -200,10 +198,10 @@ describe('Replicate data from node to node in DHT', () => {
         logger.info('after random graceful leaving, node ' + randomIndices[0] + ' is left')
 
         // @ts-expect-error private field
-        logger.info('data of ' + randomIndices[0] + ' was ' + nodes[randomIndices[0]].localDataStore.getEntry(dataKey))
+        logger.info('data of ' + randomIndices[0] + ' was ' + nodes[randomIndices[0]].localDataStore.getEntries(dataKey.value))
 
         // @ts-expect-error private field
-        expect(nodes[randomIndices[0]].localDataStore.getEntry(dataKey).size).toBeGreaterThanOrEqual(1)
+        expect(nodes[randomIndices[0]].localDataStore.getEntries(dataKey.value).size).toBeGreaterThanOrEqual(1)
 
     }, 180000)
 })

package/test/integration/RouteMessage.test.ts

@@ -1,47 +1,50 @@
 import { DhtNode, Events as DhtNodeEvents } from '../../src/dht/DhtNode'
 import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
+import { Logger, hexToBinary, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
+import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { v4 } from 'uuid'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { RoutingMode } from '../../src/dht/routing/RoutingSession'
+import { areEqualNodeIds } from '../../src/helpers/nodeId'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 const logger = new Logger(module)
 
+// TODO refactor the test to not to use PeerID
+const getPeerId = (node: DhtNode) => {
+    return PeerID.fromValue(hexToBinary(node.getNodeId()))
+}
+
+const NUM_NODES = 30
+
 describe('Route Message With Mock Connections', () => {
+
     let entryPoint: DhtNode
     let sourceNode: DhtNode
     let destinationNode: DhtNode
     let routerNodes: DhtNode[]
     let simulator: Simulator
     let entryPointDescriptor: PeerDescriptor
-
-    const entryPointId = '0'
-    const sourceId = 'eeeeeeeee'
-    const destinationId = '000000000'
-    const NUM_NODES = 30
-
     const receiveMatrix: Array<Array<number>> = []
 
     beforeEach(async () => {
         routerNodes = []
         simulator = new Simulator()
-        entryPoint = await createMockConnectionDhtNode(entryPointId, simulator)
+        entryPoint = await createMockConnectionDhtNode(simulator, createRandomNodeId())
 
         entryPointDescriptor = {
-            nodeId: entryPoint.getNodeId().value,
+            nodeId: hexToBinary(entryPoint.getNodeId()),
             type: NodeType.NODEJS
         }
 
-        sourceNode = await createMockConnectionDhtNode(sourceId, simulator)
-        destinationNode = await createMockConnectionDhtNode(destinationId, simulator)
+        sourceNode = await createMockConnectionDhtNode(simulator, createRandomNodeId())
+        destinationNode = await createMockConnectionDhtNode(simulator, createRandomNodeId())
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const nodeId = `${i}`
-            const node = await createMockConnectionDhtNode(nodeId, simulator)
+            const node = await createMockConnectionDhtNode(simulator, PeerID.fromString(`${i}`).value)
             routerNodes.push(node)
         }
 
@@ -81,7 +84,7 @@ describe('Route Message With Mock Connections', () => {
         await runAndWaitForEvents3<DhtNodeEvents>([() => {
             sourceNode.router!.doRouteMessage({
                 message,
-                destinationPeer: destinationNode.getLocalPeerDescriptor(),
+                target: destinationNode.getLocalPeerDescriptor().nodeId,
                 requestId: v4(),
                 sourcePeer: sourceNode.getLocalPeerDescriptor(),
                 reachableThrough: [],
@@ -113,7 +116,7 @@ describe('Route Message With Mock Connections', () => {
             }
             sourceNode.router!.doRouteMessage({
                 message,
-                destinationPeer: destinationNode.getLocalPeerDescriptor(),
+                target: destinationNode.getLocalPeerDescriptor().nodeId,
                 requestId: v4(),
                 sourcePeer: sourceNode.getLocalPeerDescriptor(),
                 reachableThrough: [],
@@ -134,19 +137,19 @@ describe('Route Message With Mock Connections', () => {
             receiveMatrix.push(arr)
         }
 
-        const numsOfReceivedMessages: Record<string, number> = {}
+        const numsOfReceivedMessages: Record<PeerIDKey, number> = {}
         routerNodes.forEach((node) => {
-            numsOfReceivedMessages[node.getNodeId().toKey()] = 0
+            numsOfReceivedMessages[getPeerId(node).toKey()] = 0
             node.on('message', (msg: Message) => {
-                numsOfReceivedMessages[node.getNodeId().toKey()] = numsOfReceivedMessages[node.getNodeId().toKey()] + 1
+                numsOfReceivedMessages[getPeerId(node).toKey()] = numsOfReceivedMessages[getPeerId(node).toKey()] + 1
                 try {
-                    const target = receiveMatrix[parseInt(node.getNodeId().toString()) - 1]
+                    const target = receiveMatrix[parseInt(getPeerId(node).toString()) - 1]
                     target[parseInt(PeerID.fromValue(msg.sourceDescriptor!.nodeId).toString()) - 1]++
                 } catch (e) {
                     console.error(e)
                 }
-                if (parseInt(node.getNodeId().toString()) > routerNodes.length || parseInt(node.getNodeId().toString()) === 0) {
-                    console.error(node.getNodeId().toString())
+                if (parseInt(getPeerId(node).toString()) > routerNodes.length || parseInt(getPeerId(node).toString()) === 0) {
+                    console.error(getPeerId(node).toString())
                 }
             })
         }
@@ -154,7 +157,7 @@ describe('Route Message With Mock Connections', () => {
         await Promise.all(
             routerNodes.map(async (node) =>
                 Promise.all(routerNodes.map(async (receiver) => {
-                    if (!node.getNodeId().equals(receiver.getNodeId())) {
+                    if (!areEqualNodeIds(node.getNodeId(), receiver.getNodeId())) {
                         const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
                         const message: Message = {
                             serviceId: 'nonexisting_service',
@@ -169,7 +172,7 @@ describe('Route Message With Mock Connections', () => {
                         }
                         node.router!.doRouteMessage({
                             message,
-                            destinationPeer: receiver.getLocalPeerDescriptor(),
+                            target: receiver.getLocalPeerDescriptor().nodeId,
                             sourcePeer: node.getLocalPeerDescriptor(),
                             requestId: v4(),
                             reachableThrough: [],
@@ -183,7 +186,7 @@ describe('Route Message With Mock Connections', () => {
             , 30000)
         await Promise.all(
             Object.keys(numsOfReceivedMessages).map(async (key) =>
-                waitForCondition(() => numsOfReceivedMessages[key] >= routerNodes.length - 1, 30000)
+                waitForCondition(() => numsOfReceivedMessages[key as PeerIDKey] >= routerNodes.length - 1, 30000)
             )
         )
 
@@ -205,7 +208,7 @@ describe('Route Message With Mock Connections', () => {
 
         const routeMessageWrapper: RouteMessageWrapper = {
             message: closestPeersRequestMessage,
-            destinationPeer: destinationNode.getLocalPeerDescriptor(),
+            target: destinationNode.getLocalPeerDescriptor().nodeId,
             requestId: v4(),
             sourcePeer: sourceNode.getLocalPeerDescriptor(),
             reachableThrough: [entryPointDescriptor],
@@ -237,7 +240,7 @@ describe('Route Message With Mock Connections', () => {
             message: requestMessage,
             requestId: v4(),
             sourcePeer: sourceNode.getLocalPeerDescriptor(),
-            destinationPeer: entryPoint.getLocalPeerDescriptor()!,
+            target: entryPoint.getLocalPeerDescriptor()!.nodeId,
             reachableThrough: [],
             routingPath: []
         }

package/test/integration/RouterRpcRemote.test.ts

@@ -1,24 +1,19 @@
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import { RouterRpcRemote } from '../../src/dht/routing/RouterRpcRemote'
-import { Message, MessageType, NodeType, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, MessageType, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RouterRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { createWrappedClosestPeersRequest, generateId, mockRouterRpc } from '../utils/utils'
+import { createMockPeerDescriptor, createWrappedClosestPeersRequest, mockRouterRpc } from '../utils/utils'
+
+const SERVICE_ID = 'test'
 
 describe('RemoteRouter', () => {
 
     let remoteRouter: RouterRpcRemote
     let clientRpcCommunicator: RpcCommunicator
     let serverRpcCommunicator: RpcCommunicator
-    const serviceId = 'test'
-    const clientPeerDescriptor: PeerDescriptor = {
-        nodeId: generateId('client'),
-        type: NodeType.NODEJS
-    }
-    const serverPeerDescriptor: PeerDescriptor = {
-        nodeId: generateId('server'),
-        type: NodeType.NODEJS
-    }
+    const clientPeerDescriptor = createMockPeerDescriptor()
+    const serverPeerDescriptor = createMockPeerDescriptor()
 
     beforeEach(() => {
         clientRpcCommunicator = new RpcCommunicator()
@@ -30,14 +25,13 @@ describe('RemoteRouter', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new RouterRpcClient(clientRpcCommunicator.getRpcClientTransport()))
-        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
+        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator, RouterRpcClient)
     })
 
     it('routeMessage happy path', async () => {
         const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor)
         const routed: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageId: 'routed',
             messageType: MessageType.RPC,
             body: {
@@ -49,7 +43,7 @@ describe('RemoteRouter', () => {
             requestId: 'routed',
             message: routed,
             sourcePeer: clientPeerDescriptor,
-            destinationPeer: serverPeerDescriptor,
+            target: serverPeerDescriptor.nodeId,
             reachableThrough: [],
             routingPath: []
         })
@@ -60,7 +54,7 @@ describe('RemoteRouter', () => {
         serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', mockRouterRpc.throwRouteMessageError)
         const rpcWrapper = createWrappedClosestPeersRequest(clientPeerDescriptor)
         const routed: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             messageId: 'routed',
             messageType: MessageType.RPC,
             body: {
@@ -72,7 +66,7 @@ describe('RemoteRouter', () => {
             requestId: 'routed',
             message: routed,
             sourcePeer: clientPeerDescriptor,
-            destinationPeer: serverPeerDescriptor,
+            target: serverPeerDescriptor.nodeId,
             reachableThrough: [],
             routingPath: []
         })