@streamr/dht 100.0.0-testnet-two.1 → 100.0.0-testnet-two.2

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

@@ -2,7 +2,7 @@
 
 import { SimulationNode } from './SimulationNode'
 import fs from 'fs'
-import { getNodeIdFromBinary } from '../../../src/helpers/nodeId'
+import { getDhtAddressFromRaw } from '../../../src/identifiers'
 
 export class KademliaSimulation {
     
@@ -25,7 +25,7 @@ export class KademliaSimulation {
 
     public run(): void {
         for (let i = 0; i < KademliaSimulation.NUM_NODES; i++) {
-            const node = new SimulationNode(getNodeIdFromBinary(Buffer.from(this.dhtIds[i].data.slice(0, KademliaSimulation.ID_LENGTH))))
+            const node = new SimulationNode(getDhtAddressFromRaw(Buffer.from(this.dhtIds[i].data.slice(0, KademliaSimulation.ID_LENGTH))))
             this.nodeNamesById[JSON.stringify(node.getContact().id)] = i
             this.nodes.push(node)
             node.joinDht(this.nodes[0])

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

@@ -1,8 +1,7 @@
 import KBucket from 'k-bucket'
 import { Contact } from './Contact'
 import { SortedContactList } from '../../../src/dht/contact/SortedContactList'
-import { NodeID, areEqualNodeIds } from '../../../src/helpers/nodeId'
-import { hexToBinary } from '@streamr/utils'
+import { DhtAddress, getRawFromDhtAddress } from '../../../src/identifiers'
 
 export class SimulationNode {
 
@@ -17,13 +16,13 @@ export class SimulationNode {
     private numberOfOutgoingRpcCalls = 0
 
     private neighborList: SortedContactList<Contact>
-    private ownId: NodeID
+    private ownId: DhtAddress
 
-    constructor(ownId: NodeID) {
+    constructor(ownId: DhtAddress) {
         this.ownId = ownId
         this.ownContact = new Contact(this.ownId, this)
         this.bucket = new KBucket({
-            localNodeId: hexToBinary(this.ownId),
+            localNodeId: getRawFromDhtAddress(this.ownId),
             numberOfNodesPerKBucket: this.numberOfNodesPerKBucket
         })
 
@@ -58,9 +57,9 @@ export class SimulationNode {
 
     // RPC call
 
-    public getClosestNodesTo(id: NodeID, caller: SimulationNode): Contact[] {
+    public getClosestNodesTo(id: DhtAddress, caller: SimulationNode): Contact[] {
         this.numberOfIncomingRpcCalls++
-        const idValue = hexToBinary(id)
+        const idValue = getRawFromDhtAddress(id)
         const ret = this.bucket.closest(idValue)
         if (!this.bucket.get(idValue)) {
             const contact = new Contact(id, caller)
@@ -86,12 +85,12 @@ export class SimulationNode {
     }
 
     public joinDht(entryPoint: SimulationNode): void {
-        if (areEqualNodeIds(entryPoint.getContact().getNodeId(), this.ownId)) {
+        if (entryPoint.getContact().getNodeId() === this.ownId) {
             return
         }
 
         this.bucket.add(entryPoint.getContact())
-        const closest = this.bucket.closest(hexToBinary(this.ownId), this.ALPHA)
+        const closest = this.bucket.closest(getRawFromDhtAddress(this.ownId), this.ALPHA)
 
         this.neighborList.addContacts(closest)
 
@@ -105,7 +104,7 @@ export class SimulationNode {
 
             this.findMoreContacts(uncontacted, this.neighborList)
 
-            if (areEqualNodeIds(oldClosestContactId, this.neighborList.getClosestContactId())) {
+            if (oldClosestContactId === this.neighborList.getClosestContactId()) {
                 uncontacted = this.neighborList.getUncontactedContacts(this.K)
                 if (uncontacted.length === 0) {
                     return
@@ -116,7 +115,7 @@ export class SimulationNode {
                     this.findMoreContacts(uncontacted, this.neighborList)
 
                     if (this.neighborList.getActiveContacts().length >= this.K ||
-                        areEqualNodeIds(oldClosestContactId, this.neighborList.getClosestContactId())) {
+                        (oldClosestContactId === this.neighborList.getClosestContactId())) {
                         return
                     }
                     uncontacted = this.neighborList.getUncontactedContacts(this.ALPHA)

package/test/data/generateGroundTruthData.ts

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

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

@@ -1,6 +1,6 @@
-import { binaryToHex } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/exports'
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
 
@@ -47,7 +47,7 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         })
 
         layer1EntryPoint = new DhtNode({
-            peerId: binaryToHex(entrypointDescriptor.nodeId),
+            peerId: getNodeIdFromPeerDescriptor(entrypointDescriptor),
             transport: layer0EntryPoint,
             serviceId: 'layer1'
         })

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

@@ -21,7 +21,7 @@ describe('Failed autocertification', () => {
             entryPoints: [entryPointPeerDescriptor],
             websocketServerEnableTls: true,
             autoCertifierConfigFile: os.tmpdir() + '/failedAutoCertificationConfigFile.json',
-            autoCertifierUrl: 'http://localhost:44444'
+            autoCertifierUrl: 'http://127.0.0.1:44444'
         })
 
         node = new DhtNode({

package/test/end-to-end/memory-leak.test.ts

@@ -1,9 +1,10 @@
 import LeakDetector from 'jest-leak-detector'
-import { binaryToHex, waitForCondition } from '@streamr/utils'
+import { waitForCondition } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Message, MessageType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/exports'
 
 const MESSAGE_ID = 'mock-message-id'
 
@@ -18,7 +19,7 @@ describe('memory leak', () => {
             }
         })
         let entryPoint: DhtNode | undefined = new DhtNode({
-            peerId: binaryToHex(entryPointDescriptor.nodeId),
+            peerId: getNodeIdFromPeerDescriptor(entryPointDescriptor),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
                 min: entryPointDescriptor.websocket!.port,

package/test/integration/ConnectionManager.test.ts

@@ -9,7 +9,7 @@ import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/
 import { MarkOptional } from 'ts-essentials'
 import { TransportEvents } from '../../src/transport/ITransport'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 const SERVICE_ID = 'demo'
 
@@ -363,7 +363,7 @@ describe('ConnectionManager', () => {
             messageId: '1',
             targetDescriptor: {
                 // This is not the correct nodeId of peerDescriptor2
-                nodeId: createRandomNodeId(),
+                nodeId: getRawFromDhtAddress(createRandomDhtAddress()),
                 type: NodeType.NODEJS,
                 websocket: peerDescriptor2.websocket
             },
@@ -387,7 +387,7 @@ describe('ConnectionManager', () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
-            autoCertifierUrl: 'https://localhost:12333',
+            autoCertifierUrl: 'https://127.0.0.1:12333',
             websocketServerEnableTls: true,
             websocketPortRange: { min: 10004, max: 10004 }
         })

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -1,6 +1,7 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { DhtNode } from '../../src/dht/DhtNode'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 
 const NUM_OF_NODES_PER_KBUCKET = 8
@@ -10,7 +11,7 @@ const runTest = async (latencyType: LatencyType) => {
     const entrypointDescriptor = createMockPeerDescriptor({
         region: getRandomRegion()
     })
-    const entryPoint = await createMockConnectionDhtNode(simulator, entrypointDescriptor.nodeId, NUM_OF_NODES_PER_KBUCKET)
+    const entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(entrypointDescriptor.nodeId), NUM_OF_NODES_PER_KBUCKET)
     const nodes: DhtNode[] = []
     for (let i = 1; i < 100; i++) {
         const node = await createMockConnectionDhtNode(simulator, undefined, NUM_OF_NODES_PER_KBUCKET)

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { createMockConnectionDhtNode } from '../utils/utils'
@@ -28,22 +28,22 @@ describe('DhtNodeExternalApi', () => {
 
     it('findData happy path', async () => {
         const entry = createMockDataEntry()
-        await dhtNode1.storeDataToDht(entry.key, entry.data!)
-        const foundData = await remote.findDataViaPeer(entry.key, dhtNode1.getLocalPeerDescriptor())
+        await dhtNode1.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
+        const foundData = await remote.findDataViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
         expectEqualData(foundData[0], entry)
     })
     
     it('findData returns empty array if no data found', async () => {
-        const foundData = await remote.findDataViaPeer(createRandomNodeId(), dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(createRandomDhtAddress(), dhtNode1.getLocalPeerDescriptor())
         expect(foundData).toEqual([])
     })
 
     it('external store data happy path', async () => {
         const entry = createMockDataEntry()
-        await remote.storeDataViaPeer(entry.key, entry.data!, dhtNode1.getLocalPeerDescriptor())
-        const foundData = await remote.findDataViaPeer(entry.key, dhtNode1.getLocalPeerDescriptor())
+        await remote.storeDataViaPeer(getDhtAddressFromRaw(entry.key), entry.data!, dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.findDataViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
         expectEqualData(foundData[0], entry)
-        expect(getNodeIdFromBinary(foundData[0].creator)).toEqual(getNodeIdFromPeerDescriptor(remote.getLocalPeerDescriptor()))
+        expect(getDhtAddressFromRaw(foundData[0].creator)).toEqual(getNodeIdFromPeerDescriptor(remote.getLocalPeerDescriptor()))
     })
   
 })

package/test/integration/DhtNodeRpcRemote.test.ts

@@ -8,6 +8,7 @@ import {
     PingResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 
 const SERVICE_ID = 'test'
 
@@ -45,7 +46,7 @@ describe('DhtNodeRpcRemote', () => {
     })
 
     it('getClosestPeers happy path', async () => {
-        const neighbors = await rpcRemote.getClosestPeers(clientPeerDescriptor.nodeId)
+        const neighbors = await rpcRemote.getClosestPeers(getNodeIdFromPeerDescriptor(clientPeerDescriptor))
         expect(neighbors.length).toEqual(createMockPeers().length)
     })
 
@@ -57,7 +58,7 @@ describe('DhtNodeRpcRemote', () => {
 
     it('getClosestPeers error path', async () => {
         serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.throwGetClosestPeersError)
-        await expect(rpcRemote.getClosestPeers(clientPeerDescriptor.nodeId))
+        await expect(rpcRemote.getClosestPeers(getNodeIdFromPeerDescriptor(clientPeerDescriptor)))
             .rejects.toThrow('Closest peers error')
     })
 

package/test/integration/Find.test.ts

@@ -4,7 +4,7 @@ import { PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { hexToBinary } from '@streamr/utils'
+import { getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
 
 const NUM_NODES = 100
 const K = 2
@@ -38,8 +38,8 @@ describe('Find correctness', () => {
     })
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
-        const targetId = hexToBinary(nodes[45].getNodeId())
-        const results = await entryPoint.executeRecursiveOperation(targetId, RecursiveOperation.FIND_NODE)
+        const targetId = getRawFromDhtAddress(nodes[45].getNodeId())
+        const results = await entryPoint.executeRecursiveOperation(getDhtAddressFromRaw(targetId), RecursiveOperation.FIND_NODE)
         expect(results.closestNodes.length).toBeGreaterThanOrEqual(5)
         expect(PeerID.fromValue(targetId).equals(peerIdFromPeerDescriptor(results.closestNodes[0])))
     }, 30000)

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

@@ -1,7 +1,7 @@
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node, createMockPeerDescriptor } from '../utils/utils'
-import { areEqualNodeIds } from '../../src/helpers/nodeId'
 
 const NODE_COUNT = 48
 const NUM_OF_NODES_PER_KBUCKET = 8
@@ -16,7 +16,7 @@ describe('Layer1', () => {
 
     beforeEach(async () => {
         simulator = new Simulator()
-        layer0EntryPoint = await createMockConnectionDhtNode(simulator, entryPoint0Descriptor.nodeId)
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(entryPoint0Descriptor.nodeId))
         await layer0EntryPoint.joinDht([entryPoint0Descriptor])
 
         nodes = []
@@ -62,7 +62,7 @@ describe('Layer1', () => {
         for (let i = 0; i < NODE_COUNT; i++) {
             const layer0Node = nodes[i]
             const layer1Node = layer1Nodes[i]
-            expect(areEqualNodeIds(layer1Node.getNodeId(), layer0Node.getNodeId())).toEqual(true)
+            expect(layer1Node.getNodeId()).toEqual(layer0Node.getNodeId())
             expect(layer1Node.getNumberOfConnections()).toEqual(layer0Node.getNumberOfConnections())
             expect(layer1Node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
             expect(layer1Node.getAllConnectionPeerDescriptors()).toEqual(layer0Node.getAllConnectionPeerDescriptors())

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

@@ -3,6 +3,7 @@ import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
 import { PeerID } from '../../src/exports'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -24,11 +25,11 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
     beforeEach(async () => {
 
-        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)
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('layer0entrypoint').value))
+        layer0Node1 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node1').value))
+        layer0Node2 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node2').value))
+        layer0Node3 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node3').value))
+        layer0Node4 = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString('node4').value))
 
         layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
 

package/test/integration/ReplicateData.test.ts

@@ -5,12 +5,12 @@ 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, hexToBinary } from '@streamr/utils'
+import { Logger } from '@streamr/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { Contact } from '../../src/dht/contact/Contact'
-import { NodeID } from '../../src/helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
 
 const logger = new Logger(module)
@@ -27,7 +27,7 @@ describe('Replicate data from node to node in DHT', () => {
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
     const simulator = new Simulator(LatencyType.FIXED, 20)
-    const nodesById: Map<NodeID, DhtNode> = new Map()
+    const nodesById: Map<DhtAddress, DhtNode> = new Map()
 
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('ground truth data does not exist yet, generating..')
@@ -43,12 +43,12 @@ describe('Replicate data from node to node in DHT', () => {
     beforeEach(async () => {
         nodes = []
         entryPoint = await createMockConnectionDhtNode(simulator,
-            Uint8Array.from(dhtIds[0].data), K, MAX_CONNECTIONS)
+            getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodesById.set(entryPoint.getNodeId(), entryPoint)
 
         entrypointDescriptor = {
-            nodeId: hexToBinary(entryPoint.getNodeId()),
+            nodeId: getRawFromDhtAddress(entryPoint.getNodeId()),
             type: NodeType.NODEJS
         }
 
@@ -56,7 +56,7 @@ describe('Replicate data from node to node in DHT', () => {
 
         for (let i = 1; i < NUM_NODES; i++) {
             const node = await createMockConnectionDhtNode(simulator,
-                Uint8Array.from(dhtIds[i].data), K, MAX_CONNECTIONS)
+                getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)), K, MAX_CONNECTIONS)
             nodesById.set(node.getNodeId(), node)
             nodes.push(node)
         }
@@ -74,13 +74,13 @@ 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 = createMockDataEntry({ key: dataKey.value })
+        const dataKey = getDhtAddressFromRaw(PeerID.fromString('3232323e12r31r3').value)
+        const data = createMockDataEntry({ key: dataKey })
 
         // calculate offline which node is closest to the data
 
         const sortedList = new SortedContactList<Contact>({ 
-            referenceId: dataKey.toNodeId(),
+            referenceId: dataKey,
             maxSize: 10000, 
             allowToContainReferenceId: true, 
             emitEvents: false 
@@ -103,7 +103,7 @@ 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.data!)
+        const successfulStorers = await nodes[0].storeDataToDht(dataKey, data.data!)
         expect(successfulStorers.length).toBe(1)
         logger.info('data successfully stored to node 0')
 
@@ -114,7 +114,8 @@ describe('Replicate data from node to node in DHT', () => {
             let hasDataMarker = ''
             
             // @ts-expect-error private field
-            if (node.localDataStore.getEntries(dataKey.value)) {
+            const store = node.localDataStore
+            if (store.getEntries(dataKey)) {
                 hasDataMarker = '<-'
             }
 
@@ -142,7 +143,8 @@ describe('Replicate data from node to node in DHT', () => {
             let hasDataMarker = ''
 
             // @ts-expect-error private field
-            if (node.localDataStore.getEntries(dataKey.value)) {
+            const store = node.localDataStore
+            if (store.getEntries(dataKey)) {
                 hasDataMarker = '<-'
             }
 
@@ -152,12 +154,13 @@ describe('Replicate data from node to node in DHT', () => {
         const closestNode = nodesById.get(getNodeIdFromPeerDescriptor(closest[0].getPeerDescriptor()))!
 
         // @ts-expect-error private field
-        expect(closestNode.localDataStore.getEntries(dataKey.value).size).toBeGreaterThanOrEqual(1)
+        const store = closestNode.localDataStore
+        expect(store.getEntries(dataKey).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 = createMockDataEntry({ key: dataKey.value })
+        const dataKey = getDhtAddressFromRaw(PeerID.fromString('3232323e12r31r3').value)
+        const data = createMockDataEntry({ key: dataKey })
 
         logger.info(NUM_NODES + ' nodes joining layer0 DHT')
         await Promise.all(
@@ -173,7 +176,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.data!)
+        const successfulStorers = await nodes[randomIndex].storeDataToDht(dataKey, data.data!)
 
         logger.info('data successfully stored to ' + successfulStorers + ' nodes')
 
@@ -187,10 +190,10 @@ describe('Replicate data from node to node in DHT', () => {
             const index = Math.floor(Math.random() * randomIndices.length)
             const nodeIndex = randomIndices[index]
             randomIndices.splice(index, 1)
-
+            // @ts-expect-error private field
+            const store = nodes[nodeIndex].localDataStore
             logger.info('Stopping node ' + nodeIndex + ' ' +
-                // @ts-expect-error private field
-                (nodes[nodeIndex].localDataStore.getEntries(dataKey.value) ? ', has data' : ' does not have data'))
+                (store.getEntries(dataKey) ? ', has data' : ' does not have data'))
 
             await nodes[nodeIndex].stop()
         }
@@ -198,10 +201,9 @@ 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.getEntries(dataKey.value))
-
-        // @ts-expect-error private field
-        expect(nodes[randomIndices[0]].localDataStore.getEntries(dataKey.value).size).toBeGreaterThanOrEqual(1)
+        const firstStore = nodes[randomIndices[0]].localDataStore
+        logger.info('data of ' + randomIndices[0] + ' was ' + firstStore.getEntries(dataKey))
+        expect(firstStore.getEntries(dataKey).size).toBeGreaterThanOrEqual(1)
 
     }, 180000)
 })

package/test/integration/RouteMessage.test.ts

@@ -1,21 +1,20 @@
 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, hexToBinary, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
+import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
 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'
+import { createRandomDhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
 // TODO refactor the test to not to use PeerID
 const getPeerId = (node: DhtNode) => {
-    return PeerID.fromValue(hexToBinary(node.getNodeId()))
+    return PeerID.fromValue(getRawFromDhtAddress(node.getNodeId()))
 }
 
 const NUM_NODES = 30
@@ -33,18 +32,18 @@ describe('Route Message With Mock Connections', () => {
     beforeEach(async () => {
         routerNodes = []
         simulator = new Simulator()
-        entryPoint = await createMockConnectionDhtNode(simulator, createRandomNodeId())
+        entryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
 
         entryPointDescriptor = {
-            nodeId: hexToBinary(entryPoint.getNodeId()),
+            nodeId: getRawFromDhtAddress(entryPoint.getNodeId()),
             type: NodeType.NODEJS
         }
 
-        sourceNode = await createMockConnectionDhtNode(simulator, createRandomNodeId())
-        destinationNode = await createMockConnectionDhtNode(simulator, createRandomNodeId())
+        sourceNode = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        destinationNode = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, PeerID.fromString(`${i}`).value)
+            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(PeerID.fromString(`${i}`).value))
             routerNodes.push(node)
         }
 
@@ -157,7 +156,7 @@ describe('Route Message With Mock Connections', () => {
         await Promise.all(
             routerNodes.map(async (node) =>
                 Promise.all(routerNodes.map(async (receiver) => {
-                    if (!areEqualNodeIds(node.getNodeId(), receiver.getNodeId())) {
+                    if (node.getNodeId() !== receiver.getNodeId()) {
                         const rpcWrapper = createWrappedClosestPeersRequest(sourceNode.getLocalPeerDescriptor())
                         const message: Message = {
                             serviceId: 'nonexisting_service',

package/test/integration/RouterRpcRemote.test.ts

@@ -25,7 +25,7 @@ describe('RemoteRouter', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator, RouterRpcClient)
+        remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, RouterRpcClient)
     })
 
     it('routeMessage happy path', async () => {

package/test/integration/ScaleDownDht.test.ts

@@ -3,9 +3,9 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { Logger, hexToBinary } from '@streamr/utils'
+import { Logger } from '@streamr/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -23,11 +23,11 @@ describe('Scaling down a Dht network', () => {
     beforeEach(async () => {
         nodes = []
         entryPoint = await createMockConnectionDhtNode(simulator,
-            createRandomNodeId(), K, MAX_CONNECTIONS)
+            createRandomDhtAddress(), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
 
         entrypointDescriptor = {
-            nodeId: hexToBinary(entryPoint.getNodeId()),
+            nodeId: getRawFromDhtAddress(entryPoint.getNodeId()),
             type: NodeType.NODEJS,
             region: getRandomRegion()
         }