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

package/test/benchmark/KademliaCorrectness.test.ts

@@ -5,7 +5,7 @@ import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDes
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
-import { NodeID } from '../../src/helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('Kademlia correctness', () => {
     let entryPoint: DhtNode
@@ -13,7 +13,7 @@ describe('Kademlia correctness', () => {
     const simulator = new Simulator()
     const NUM_NODES = 1000
 
-    const nodeIndicesById: Record<NodeID, number> = {}
+    const nodeIndicesById: Record<DhtAddress, number> = {}
 
     if (!fs.existsSync('test/data/nodeids.json')) {
         console.log('gound truth data does not exist yet, generating..')
@@ -27,12 +27,12 @@ describe('Kademlia correctness', () => {
     beforeEach(async () => {
 
         nodes = []
-        entryPoint = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[0].data), 8)
+        entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[0].data)), 8)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId()] = 0
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, Uint8Array.from(dhtIds[i].data))
+            const node = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(Uint8Array.from(dhtIds[i].data)))
             nodeIndicesById[node.getNodeId()] = i
             nodes.push(node)
         }

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -3,19 +3,20 @@
 import KBucket from 'k-bucket'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import crypto from 'crypto'
-import { NodeID, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw } from '../../src/identifiers'
 
 const NUM_ADDS = 1000
+
 interface Item {
-    id: Uint8Array
+    id: DhtAddressRaw
     vectorClock: number
-    getNodeId: () => NodeID
+    getNodeId: () => DhtAddress
 }
 
 const createRandomItem = (index: number): Item => {
     const rand = new Uint8Array(crypto.randomBytes(20))
     return {
-        getNodeId: () => getNodeIdFromBinary(rand),
+        getNodeId: () => getDhtAddressFromRaw(rand),
         id: rand,
         vectorClock: index
     }
@@ -37,7 +38,7 @@ describe('SortedContactListBenchmark', () => {
             randomIds.push(createRandomItem(i))
         }
         const list = new SortedContactList({
-            referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+            referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
             allowToContainReferenceId: true,
             emitEvents: true
         })
@@ -49,7 +50,7 @@ describe('SortedContactListBenchmark', () => {
         console.timeEnd('SortedContactList.addContact() with emitEvents=true')
 
         const list2 = new SortedContactList({
-            referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+            referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
             allowToContainReferenceId: true,
             emitEvents: false
         })
@@ -83,13 +84,13 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=true')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: true
             })
 
             const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.map((contact) => closest.addContact(contact))
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
         console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=true')
@@ -97,13 +98,13 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
 
             const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.map((contact) => closest.addContact(contact))
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
         console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false')
@@ -111,13 +112,13 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
 
             const arrayFromBucket = kBucket.toArray()
-            arrayFromBucket.map((contact) => closest.addContact(contact))
+            arrayFromBucket.forEach((contact) => closest.addContact(contact))
             closest.getClosestContacts(20)
         }
         console.timeEnd('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
@@ -125,7 +126,7 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getNodeIdFromBinary(crypto.randomBytes(20)),
+                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -141,7 +142,7 @@ describe('SortedContactListBenchmark', () => {
         for (let i = 0; i < NUM_ADDS; i++) {
             const bucket2 = new KBucket<Item>({ localNodeId: crypto.randomBytes(20) })
 
-            shuffled.map((contact) => bucket2.add(contact))
+            shuffled.forEach((contact) => bucket2.add(contact))
             bucket2.closest(crypto.randomBytes(20), 20)
         }
         console.timeEnd('kbucket add and closest')

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

@@ -1,32 +1,31 @@
 import type { SimulationNode } from './SimulationNode'
 import { NodeType, PeerDescriptor } from '../../../src/proto/packages/dht/protos/DhtRpc'
-import { NodeID } from '../../../src/helpers/nodeId'
-import { hexToBinary } from '@streamr/utils'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../../../src/identifiers'
 
 export class Contact {
     private static counter = 0
 
-    public ownId: NodeID
-    public id: Uint8Array
+    public ownId: DhtAddress
+    public id: DhtAddressRaw
     public vectorClock = 0
     public dhtNode: SimulationNode | undefined
 
-    constructor(ownId: NodeID, dhtNode?: SimulationNode) {
+    constructor(ownId: DhtAddress, dhtNode?: SimulationNode) {
         this.ownId = ownId
         this.vectorClock = Contact.counter++
         this.dhtNode = dhtNode
-        this.id = hexToBinary(ownId)
+        this.id = getRawFromDhtAddress(ownId)
     }
 
     getPeerDescriptor(): PeerDescriptor {
         const peerDescriptor: PeerDescriptor = {
-            nodeId: hexToBinary(this.ownId),
+            nodeId: getRawFromDhtAddress(this.ownId),
             type: NodeType.NODEJS
         }
         return peerDescriptor
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return this.ownId
     }
 

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)