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

package/test/integration/SimultaneousConnections.test.ts

@@ -3,11 +3,10 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, MessageType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
 import { MockTransport } from '../utils/mock/Transport'
 
 const BASE_MESSAGE: Message = {
@@ -88,27 +87,23 @@ describe('SimultaneousConnections', () => {
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
         
-        const wsPeerDescriptor1: PeerDescriptor = {
-            nodeId: createRandomNodeId(),
-            type: NodeType.NODEJS,
+        const wsPeerDescriptor1 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 43432,
                 tls: false
             },
             region: getRandomRegion()
-        }
+        })
 
-        const wsPeerDescriptor2: PeerDescriptor = {
-            nodeId: createRandomNodeId(),
-            type: NodeType.NODEJS,
+        const wsPeerDescriptor2 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 43433,
                 tls: false
             },
             region: getRandomRegion()
-        }
+        })
 
         beforeEach(async () => {
 
@@ -176,16 +171,14 @@ describe('SimultaneousConnections', () => {
         let connectionManager1: ConnectionManager
         let connectionManager2: ConnectionManager
 
-        const wsPeerDescriptor1: PeerDescriptor = {
-            nodeId: createRandomNodeId(),
-            type: NodeType.NODEJS,
+        const wsPeerDescriptor1 = createMockPeerDescriptor({
             websocket: {
                 host: '127.0.0.1',
                 port: 43432,
                 tls: false
             },
             region: getRandomRegion()
-        }
+        })
 
         const wsPeerDescriptor2 = createMockPeerDescriptor({ region: getRandomRegion() })
 

package/test/integration/Store.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
@@ -44,17 +44,23 @@ describe('Storing data in DHT', () => {
     it('Storing data works', async () => {
         const storingNodeIndex = 34
         const entry = createMockDataEntry()
-        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(entry.key, entry.data!)
+        const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(
+            getDhtAddressFromRaw(entry.key),
+            entry.data!
+        )
         expect(successfulStorers.length).toBeGreaterThan(4)
     }, 30000)
 
     it('Storing and getting data works', async () => {
         const storingNode = getRandomNode()
         const entry = createMockDataEntry()
-        const successfulStorers = await storingNode.storeDataToDht(entry.key, entry.data!)
+        const successfulStorers = await storingNode.storeDataToDht(
+            getDhtAddressFromRaw(entry.key),
+            entry.data!
+        )
         expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(entry.key)
+        const results = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
         results.forEach((result) => {
             expectEqualData(result, entry)
         })
@@ -64,13 +70,17 @@ describe('Storing data in DHT', () => {
         const storingNode = getRandomNode()
         const entry = createMockDataEntry()
         const requestor = createMockPeerDescriptor()
-        const successfulStorers = await storingNode.storeDataToDht(entry.key, entry.data!, getNodeIdFromBinary(requestor.nodeId))
+        const successfulStorers = await storingNode.storeDataToDht(
+            getDhtAddressFromRaw(entry.key),
+            entry.data!,
+            getDhtAddressFromRaw(requestor.nodeId)
+        )
         expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(entry.key)
+        const results = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
         results.forEach((result) => {
             expectEqualData(result, entry)
-            expect(getNodeIdFromBinary(result.creator)).toEqual(getNodeIdFromPeerDescriptor(requestor))
+            expect(getDhtAddressFromRaw(result.creator)).toEqual(getNodeIdFromPeerDescriptor(requestor))
         })
     }, 30000)
 })

package/test/integration/StoreAndDelete.test.ts

@@ -2,7 +2,8 @@ import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { createRandomDhtAddress } from '../../src/identifiers'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 const NUM_NODES = 5
 const MAX_CONNECTIONS = 5
@@ -20,7 +21,7 @@ describe('Storing data in DHT', () => {
     beforeEach(async () => {
         nodes = []
         const entryPoint = await createMockConnectionDhtNode(simulator,
-            createRandomNodeId(), K, MAX_CONNECTIONS)
+            createRandomDhtAddress(), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const node = await createMockConnectionDhtNode(simulator, 
@@ -38,11 +39,11 @@ describe('Storing data in DHT', () => {
     it('Data can be deleted', async () => {
         const storingNode = getRandomNode()
         const entry = createMockDataEntry()
-        const successfulStorers = await storingNode.storeDataToDht(entry.key, entry.data!)
+        const successfulStorers = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
         expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(entry.key, true)
+        await storingNode.deleteDataFromDht(getDhtAddressFromRaw(entry.key), true)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(entry.key)
+        const results = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
         results.forEach((result) => {
             expect(result.deleted).toBeTrue()
             expectEqualData(result, entry)
@@ -52,18 +53,18 @@ describe('Storing data in DHT', () => {
     it('Data can be deleted and re-stored', async () => {
         const storingNode = getRandomNode()
         const entry = createMockDataEntry()
-        const successfulStorers1 = await storingNode.storeDataToDht(entry.key, entry.data!)
+        const successfulStorers1 = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
         expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(entry.key, true)
+        await storingNode.deleteDataFromDht(getDhtAddressFromRaw(entry.key), true)
         const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.getDataFromDht(entry.key)
+        const results1 = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
         results1.forEach((result) => {
             expect(result.deleted).toBeTrue()
             expectEqualData(result, entry)
         })
-        const successfulStorers2 = await storingNode.storeDataToDht(entry.key, entry.data!)
+        const successfulStorers2 = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
         expect(successfulStorers2.length).toBeGreaterThan(4)
-        const results2 = await fetchingNode.getDataFromDht(entry.key)
+        const results2 = await fetchingNode.getDataFromDht(getDhtAddressFromRaw(entry.key))
         results2.forEach((result) => {
             expect(result.deleted).toBeFalse()
             expectEqualData(result, entry)

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -3,6 +3,7 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { waitForCondition } from '@streamr/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('Storing data in DHT with two peers', () => {
 
@@ -31,10 +32,10 @@ describe('Storing data in DHT with two peers', () => {
     it('Node can store on two peer DHT', async () => {
         const storedData1 = createMockDataEntry()
         const storedData2 = createMockDataEntry()
-        await otherNode.storeDataToDht(storedData1.key, storedData1.data!)
-        await entryPoint.storeDataToDht(storedData2.key, storedData2.data!)
-        const foundData1 = await otherNode.getDataFromDht(storedData1.key)
-        const foundData2 = await entryPoint.getDataFromDht(storedData2.key)
+        await otherNode.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
+        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData2.key), storedData2.data!)
+        const foundData1 = await otherNode.getDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        const foundData2 = await entryPoint.getDataFromDht(getDhtAddressFromRaw(storedData2.key))
         expectEqualData(foundData1[0], storedData1)
         expectEqualData(foundData2[0], storedData2)
     })
@@ -43,8 +44,8 @@ describe('Storing data in DHT with two peers', () => {
         await otherNode.stop()
         await waitForCondition(() => entryPoint.getNumberOfNeighbors() === 0)
         const storedData = createMockDataEntry()
-        await entryPoint.storeDataToDht(storedData.key, storedData.data!)
-        const foundData = await entryPoint.getDataFromDht(storedData.key)
+        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData.key), storedData.data!)
+        const foundData = await entryPoint.getDataFromDht(getDhtAddressFromRaw(storedData.key))
         expectEqualData(foundData[0], storedData)
     }, 60000)
 })

package/test/integration/StoreRpcRemote.test.ts

@@ -9,9 +9,7 @@ import { StoreRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.clien
 import { StoreRpcRemote } from '../../src/dht/store/StoreRpcRemote'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
 import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
-
-const SERVICE_ID = 'test'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 describe('StoreRpcRemote', () => {
 
@@ -24,7 +22,7 @@ describe('StoreRpcRemote', () => {
     const request: StoreDataRequest = {
         key: data.key,
         data: data.data,
-        creator: createRandomNodeId(),
+        creator: getRawFromDhtAddress(createRandomDhtAddress()),
         ttl: 10
     }
 
@@ -38,7 +36,7 @@ describe('StoreRpcRemote', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator, StoreRpcClient)
+        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, StoreRpcClient)
     })
 
     it('storeData happy path', async () => {

package/test/unit/AddressTools.test.ts

@@ -37,4 +37,8 @@ describe('isPrivateIPv4', () => {
     it('return false for a public address', () => {
         expect(isPrivateIPv4('203.0.113.181')).toBe(false)
     })
+
+    it('return true for localhost IP address', () => {
+        expect(isPrivateIPv4('127.0.0.1')).toBe(true)
+    })
 })

package/test/unit/LocalDataStore.test.ts

@@ -2,17 +2,16 @@ import { wait } from '@streamr/utils'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import {
     getNodeIdFromPeerDescriptor,
-    peerIdFromPeerDescriptor
 } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { DhtAddress, createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('LocalDataStore', () => {
 
     let localDataStore: LocalDataStore
 
-    const getEntryArray = (key: Uint8Array) => {
+    const getEntryArray = (key: DhtAddress) => {
         return Array.from(localDataStore.getEntries(key).values())
     }
     
@@ -27,84 +26,93 @@ describe('LocalDataStore', () => {
     it('can store', () => {
         const storedEntry = createMockDataEntry()
         localDataStore.storeEntry(storedEntry)
-        const fetchedEntries = getEntryArray(storedEntry.key)
+        const fetchedEntries = getEntryArray(getDhtAddressFromRaw(storedEntry.key))
         expect(fetchedEntries).toHaveLength(1)
         expectEqualData(fetchedEntries[0], storedEntry)
     })
 
     it('multiple storers behind one key', () => {
-        const creator1 = createRandomNodeId()
-        const creator2 = createRandomNodeId()
-        const key = createRandomNodeId()
+        const creator1 = createRandomDhtAddress()
+        const creator2 = createRandomDhtAddress()
+        const key = createRandomDhtAddress()
         const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
         localDataStore.storeEntry(storedEntry2)
         const fetchedEntries = localDataStore.getEntries(key)
         expect(fetchedEntries.size).toBe(2)
-        expectEqualData(fetchedEntries.get(getNodeIdFromBinary(creator1))!, storedEntry1)
-        expectEqualData(fetchedEntries.get(getNodeIdFromBinary(creator2))!, storedEntry2)
+        expectEqualData(fetchedEntries.get(creator1)!, storedEntry1)
+        expectEqualData(fetchedEntries.get(creator2)!, storedEntry2)
     })
 
     it('can remove data entries', () => {
-        const creator1 = createRandomNodeId()
-        const creator2 = createRandomNodeId()
-        const key = createRandomNodeId()
+        const creator1 = createRandomDhtAddress()
+        const creator2 = createRandomDhtAddress()
+        const key = createRandomDhtAddress()
         const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
         localDataStore.storeEntry(storedEntry2)
-        localDataStore.deleteEntry(key, getNodeIdFromBinary(creator1))
+        localDataStore.deleteEntry(key, creator1)
         const fetchedEntries = getEntryArray(key)
         expect(fetchedEntries).toHaveLength(1)
         expectEqualData(fetchedEntries[0], storedEntry2)
     })
 
     it('can remove all data entries', () => {
-        const creator1 = createRandomNodeId()
-        const creator2 = createRandomNodeId()
-        const key = createRandomNodeId()
+        const creator1 = createRandomDhtAddress()
+        const creator2 = createRandomDhtAddress()
+        const key = createRandomDhtAddress()
         const storedEntry1 = createMockDataEntry({ key, creator: creator1 })
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
         localDataStore.storeEntry(storedEntry2)
-        localDataStore.deleteEntry(key, getNodeIdFromBinary(creator1))
-        localDataStore.deleteEntry(key, getNodeIdFromBinary(creator2))
+        localDataStore.deleteEntry(key, creator1)
+        localDataStore.deleteEntry(key, creator2)
         expect(getEntryArray(key)).toHaveLength(0)
     })
 
     it('data is deleted after TTL', async () => {
         const storedEntry = createMockDataEntry({ ttl: 1000 })
         localDataStore.storeEntry(storedEntry)
-        expect(getEntryArray(storedEntry.key)).toHaveLength(1)
+        expect(getEntryArray(getDhtAddressFromRaw(storedEntry.key))).toHaveLength(1)
         await wait(1100)
-        expect(getEntryArray(storedEntry.key)).toHaveLength(0)
+        expect(getEntryArray(getDhtAddressFromRaw(storedEntry.key))).toHaveLength(0)
     })
 
     describe('mark data as deleted', () => {
 
         it('happy path', () => {
-            const creator1 = createRandomNodeId()
+            const creator1 = createRandomDhtAddress()
             const storedEntry = createMockDataEntry({ creator: creator1 })
             localDataStore.storeEntry(storedEntry)
-            const notDeletedData = localDataStore.getEntries(storedEntry.key)
-            expect(notDeletedData.get(getNodeIdFromBinary(creator1))!.deleted).toBeFalse()
-            const returnValue = localDataStore.markAsDeleted(storedEntry.key, getNodeIdFromBinary(creator1))
+            const notDeletedData = localDataStore.getEntries(getDhtAddressFromRaw(storedEntry.key))
+            expect(notDeletedData.get(creator1)!.deleted).toBeFalse()
+            const returnValue = localDataStore.markAsDeleted(
+                getDhtAddressFromRaw(storedEntry.key),
+                creator1
+            )
             expect(returnValue).toBe(true)
-            const deletedData = localDataStore.getEntries(storedEntry.key)
-            expect(deletedData.get(getNodeIdFromBinary(creator1))!.deleted).toBeTrue()
+            const deletedData = localDataStore.getEntries(getDhtAddressFromRaw(storedEntry.key))
+            expect(deletedData.get(creator1)!.deleted).toBeTrue()
         })
 
         it('data not stored', () => {
-            const dataKey = peerIdFromPeerDescriptor(createMockPeerDescriptor())
-            const returnValue = localDataStore.markAsDeleted(dataKey.value, getNodeIdFromPeerDescriptor(createMockPeerDescriptor()))
+            const key = createRandomDhtAddress()
+            const returnValue = localDataStore.markAsDeleted(
+                key,
+                getNodeIdFromPeerDescriptor(createMockPeerDescriptor())
+            )
             expect(returnValue).toBe(false)
         })
 
         it('data not stored by the given creator', () => {
             const storedEntry = createMockDataEntry()
             localDataStore.storeEntry(storedEntry)
-            const returnValue = localDataStore.markAsDeleted(storedEntry.key, getNodeIdFromPeerDescriptor(createMockPeerDescriptor()))
+            const returnValue = localDataStore.markAsDeleted(
+                getDhtAddressFromRaw(storedEntry.key),
+                getNodeIdFromPeerDescriptor(createMockPeerDescriptor())
+            )
             expect(returnValue).toBe(false)
         })
     })

package/test/unit/PeerManager.test.ts

@@ -1,6 +1,5 @@
-import { hexToBinary } from '@streamr/utils'
 import { PeerManager, getDistance } from '../../src/dht/PeerManager'
-import { NodeID, createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { range, sampleSize, sortBy, without } from 'lodash'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
@@ -9,22 +8,22 @@ import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 describe('PeerManager', () => {
 
     it('getClosestContactsTo', () => {
-        const nodeIds = range(10).map(() => getNodeIdFromBinary(createRandomNodeId()))
+        const nodeIds = range(10).map(() => createRandomDhtAddress())
         const manager = new PeerManager({
-            localNodeId: getNodeIdFromBinary(createRandomNodeId()),
+            localNodeId: createRandomDhtAddress(),
             createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => {
                 return new DhtNodeRpcRemote(undefined as any, peerDescriptor, undefined as any, new MockRpcCommunicator())
             }
         } as any)
-        manager.handleNewPeers(nodeIds.map((n) => ({ nodeId: hexToBinary(n), type: NodeType.NODEJS })))
+        manager.handleNewPeers(nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS })))
 
-        const referenceId = getNodeIdFromBinary(createRandomNodeId())
-        const excluded = new Set<NodeID>(sampleSize(nodeIds, 2)!)
+        const referenceId = createRandomDhtAddress()
+        const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2)!)
         const actual = manager.getClosestContactsTo(referenceId, 5, excluded)
 
         const expected = sortBy(
             without(nodeIds, ...Array.from(excluded.values())),
-            (n: NodeID) => getDistance(n, referenceId)
+            (n: DhtAddress) => getDistance(getRawFromDhtAddress(n), getRawFromDhtAddress(referenceId))
         ).slice(0, 5)
         expect(actual.map((n) => n.getNodeId())).toEqual(expected)
     })

package/test/unit/RandomContactList.test.ts

@@ -1,10 +1,10 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
 import { PeerID } from '../../src/helpers/PeerID'
-import { NodeID, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw } from '../../src/identifiers'
 
-const createItem = (nodeId: Uint8Array): { getNodeId: () => NodeID, getPeerId: () => PeerID } => {
+const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress, getPeerId: () => PeerID } => {
     return { 
-        getNodeId: () => getNodeIdFromBinary(nodeId),
+        getNodeId: () => getDhtAddressFromRaw(nodeId),
         getPeerId: () => PeerID.fromValue(nodeId)
     }
 }

package/test/unit/RecursiveOperationManager.test.ts

@@ -21,6 +21,7 @@ import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescrip
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 import { Router } from '../../src/dht/routing/Router'
 import { ITransport } from '../../src/exports'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
     return {
@@ -85,7 +86,7 @@ describe('RecursiveOperationManager', () => {
 
     it('startFind with mode Node returns self if no peers', async () => {
         const recursiveOperationManager = createRecursiveOperationManager()
-        const res = await recursiveOperationManager.execute(PeerID.fromString('find').value, RecursiveOperation.FIND_NODE)
+        const res = await recursiveOperationManager.execute(getDhtAddressFromRaw(PeerID.fromString('find').value), RecursiveOperation.FIND_NODE)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
         recursiveOperationManager.stop()
     })

package/test/unit/RecursiveOperationSession.test.ts

@@ -3,7 +3,7 @@ import { range } from 'lodash'
 import { RecursiveOperationSession } from '../../src/dht/recursive-operation/RecursiveOperationSession'
 import { RecursiveOperationSessionRpcRemote } from '../../src/dht/recursive-operation/RecursiveOperationSessionRpcRemote'
 import { ServiceID } from '../../src/exports'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { createRandomDhtAddress } from '../../src/identifiers'
 import { Message, PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RecursiveOperationSessionRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
@@ -21,7 +21,6 @@ describe('RecursiveOperationSession', () => {
         return new RecursiveOperationSessionRpcRemote(
             createMockPeerDescriptor(),
             localPeerDescriptor,
-            serviceId,
             new RoutingRpcCommunicator(serviceId, send),
             RecursiveOperationSessionRpcClient
         )
@@ -36,7 +35,7 @@ describe('RecursiveOperationSession', () => {
         const doRouteRequest = jest.fn()
         const session = new RecursiveOperationSession({
             transport: environment.createTransport(),
-            targetId: createRandomNodeId(),
+            targetId: createRandomDhtAddress(),
             localPeerDescriptor,
             waitedRoutingPathCompletions: 3,
             operation: RecursiveOperation.FIND_NODE,

package/test/unit/Router.test.ts

@@ -12,7 +12,7 @@ import {
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-import { NodeID } from '../../src/helpers/nodeId'
+import { DhtAddress } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('Router', () => {
@@ -40,7 +40,7 @@ describe('Router', () => {
         target: peerDescriptor1.nodeId,
         sourcePeer: peerDescriptor2
     }
-    let connections: Map<NodeID, DhtNodeRpcRemote>
+    let connections: Map<DhtAddress, DhtNodeRpcRemote>
     const rpcCommunicator = new FakeRpcCommunicator()
 
     const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {

package/test/unit/RoutingSession.test.ts

@@ -5,13 +5,13 @@ import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../u
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
 import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { NodeID } from '../../src/helpers/nodeId'
+import { DhtAddress } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('RoutingSession', () => {
 
     let session: RoutingSession
-    let connections: Map<NodeID, DhtNodeRpcRemote>
+    let connections: Map<DhtAddress, DhtNodeRpcRemote>
     let rpcCommunicator: RoutingRpcCommunicator
     const mockPeerDescriptor1 = createMockPeerDescriptor()
     const mockPeerDescriptor2 = createMockPeerDescriptor()

package/test/unit/SortedContactList.test.ts

@@ -1,10 +1,10 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { PeerID } from '../../src/helpers/PeerID'
-import { NodeID, createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
-const createItem = (nodeId: Uint8Array): { getNodeId: () => NodeID, getPeerId: () => PeerID } => {
+const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress, getPeerId: () => PeerID } => {
     return { 
-        getNodeId: () => getNodeIdFromBinary(nodeId),
+        getNodeId: () => getDhtAddressFromRaw(nodeId),
         getPeerId: () => PeerID.fromValue(nodeId)
     }
 }
@@ -72,7 +72,7 @@ describe('SortedContactList', () => {
         const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 8, allowToContainReferenceId: false, emitEvents: true })
         const onContactRemoved = jest.fn()
         list.on('contactRemoved', onContactRemoved)
-        list.removeContact(getNodeIdFromBinary(createRandomNodeId()))
+        list.removeContact(createRandomDhtAddress())
         list.addContact(item3)
         list.removeContact(item3.getNodeId())
         list.addContact(item4)
@@ -84,10 +84,10 @@ describe('SortedContactList', () => {
         expect(list.getContact(item2.getNodeId())).toBeFalsy()
         expect(list.getContactIds()).toEqual(list.getContactIds().sort(list.compareIds))
         expect(list.getAllContacts()).toEqual([item1, item3, item4])
-        const ret = list.removeContact(getNodeIdFromBinary(Buffer.from([0, 0, 0, 6])))
+        const ret = list.removeContact(getDhtAddressFromRaw(Buffer.from([0, 0, 0, 6])))
         expect(ret).toEqual(false)
         list.removeContact(item3.getNodeId())
-        list.removeContact(getNodeIdFromBinary(createRandomNodeId()))
+        list.removeContact(createRandomDhtAddress())
         expect(list.getAllContacts()).toEqual([item1, item4])
         expect(onContactRemoved).toHaveBeenNthCalledWith(1, item3, [])
         expect(onContactRemoved).toHaveBeenNthCalledWith(2, item2, [item1, item3, item4])