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

package/test/unit/LocalDataStore.test.ts

@@ -2,20 +2,15 @@ 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 { createMockDataEntry } from '../utils/mock/mockDataEntry'
+import { createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('LocalDataStore', () => {
 
     let localDataStore: LocalDataStore
 
-    const getEntryArray = (key: Uint8Array) => {
-        return Array.from(localDataStore.getEntries(key).values())
-    }
-    
     beforeEach(() => {
         localDataStore = new LocalDataStore(30 * 1000)
     })
@@ -27,84 +22,89 @@ describe('LocalDataStore', () => {
     it('can store', () => {
         const storedEntry = createMockDataEntry()
         localDataStore.storeEntry(storedEntry)
-        const fetchedEntries = getEntryArray(storedEntry.key)
-        expect(fetchedEntries).toHaveLength(1)
-        expectEqualData(fetchedEntries[0], storedEntry)
+        const fetchedEntries = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+        expect(fetchedEntries).toIncludeSameMembers([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)
+        const fetchedEntries = Array.from(localDataStore.values(key))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry1, 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))
-        const fetchedEntries = getEntryArray(key)
-        expect(fetchedEntries).toHaveLength(1)
-        expectEqualData(fetchedEntries[0], storedEntry2)
+        localDataStore.deleteEntry(key, creator1)
+        const fetchedEntries = Array.from(localDataStore.values(key))
+        expect(fetchedEntries).toIncludeSameMembers([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))
-        expect(getEntryArray(key)).toHaveLength(0)
+        localDataStore.deleteEntry(key, creator1)
+        localDataStore.deleteEntry(key, creator2)
+        expect(Array.from(localDataStore.values(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(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(1)
         await wait(1100)
-        expect(getEntryArray(storedEntry.key)).toHaveLength(0)
+        expect(Array.from(localDataStore.values(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 = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            expect(notDeletedData[0]!.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 = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            expect(deletedData[0]!.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])

package/test/unit/StoreManager.test.ts

@@ -1,19 +1,22 @@
 import { wait, waitForCondition } from '@streamr/utils'
-import crypto from 'crypto'
 import { range, sortBy } from 'lodash'
-import { Key } from 'readline'
 import { getDistance } from '../../src/dht/PeerManager'
 import { StoreManager } from '../../src/dht/store/StoreManager'
-import { NodeID, createRandomNodeId, getNodeIdFromBinary } from '../../src/helpers/nodeId'
+import {
+    DhtAddress,
+    createRandomDhtAddress,
+    getDhtAddressFromRaw,
+    getRawFromDhtAddress,
+} from '../../src/identifiers'
 import { NodeType, ReplicateDataRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
 
 const DATA_ENTRY = {
-    key: createRandomNodeId(),
-    creator: crypto.randomBytes(20)
+    key: getRawFromDhtAddress(createRandomDhtAddress()),
+    creator: getRawFromDhtAddress(createRandomDhtAddress())
 }
 const NODES_CLOSEST_TO_DATA = sortBy(
-    range(5).map(() => createRandomNodeId()),
-    (id: Uint8Array) => getDistance(getNodeIdFromBinary(id), getNodeIdFromBinary(DATA_ENTRY.key))
+    range(5).map(() => createRandomDhtAddress()),
+    (id: DhtAddress) => getDistance(getRawFromDhtAddress(id), DATA_ENTRY.key)
 )
 
 describe('StoreManager', () => {
@@ -21,13 +24,13 @@ describe('StoreManager', () => {
     describe('new contact', () => {
 
         const createStoreManager = (
-            localNodeId: Uint8Array,
-            closestNeighbors: Uint8Array[],
+            localNodeId: DhtAddress,
+            closestNeighbors: DhtAddress[],
             replicateData: (request: ReplicateDataRequest) => unknown,
-            setStale: (key: Key, creator: NodeID, stale: boolean) => unknown
+            setStale: (key: DhtAddress, creator: DhtAddress, stale: boolean) => unknown
         ): StoreManager => {
             const getClosestNeighborsTo = () => {
-                return closestNeighbors.map((nodeId) => ({ nodeId, type: NodeType.NODEJS }))
+                return closestNeighbors.map((nodeId) => ({ nodeId: getRawFromDhtAddress(nodeId), type: NodeType.NODEJS }))
             }
             return new StoreManager({
                 rpcCommunicator: {
@@ -35,7 +38,7 @@ describe('StoreManager', () => {
                     registerRpcNotification: () => {}
                 } as any,
                 recursiveOperationManager: undefined as any,
-                localPeerDescriptor: { nodeId: localNodeId, type: NodeType.NODEJS },
+                localPeerDescriptor: { nodeId: getRawFromDhtAddress(localNodeId), type: NodeType.NODEJS },
                 localDataStore: { values: () => [DATA_ENTRY], setStale } as any,
                 serviceId: undefined as any,
                 highestTtl: undefined as any,
@@ -49,14 +52,14 @@ describe('StoreManager', () => {
 
             it('new node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[0],
                     [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[3], NODES_CLOSEST_TO_DATA[4]],
                     replicateData,
                     setStale
                 )
-                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[2], type: NodeType.NODEJS })
+                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
                 await waitForCondition(() => replicateData.mock.calls.length === 1)
                 expect(replicateData).toHaveBeenCalledWith({
                     entry: DATA_ENTRY
@@ -66,14 +69,14 @@ describe('StoreManager', () => {
     
             it('new node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[0],
                     [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
                     replicateData,
                     setStale
                 )
-                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setStale).not.toHaveBeenCalled()
@@ -84,14 +87,14 @@ describe('StoreManager', () => {
 
             it('this node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[1],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
                     replicateData,
                     setStale
                 )
-                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setStale).not.toHaveBeenCalled()
@@ -99,30 +102,30 @@ describe('StoreManager', () => {
 
             it('this node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[3],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2]],
                     replicateData,
                     setStale
                 )
-                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setStale).toHaveBeenCalledTimes(1)
-                expect(setStale).toHaveBeenCalledWith(DATA_ENTRY.key, getNodeIdFromBinary(DATA_ENTRY.creator), true)
+                expect(setStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key), getDhtAddressFromRaw(DATA_ENTRY.creator), true)
             })
 
             it('this node has less than redundancyFactor neighbors', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [Key, NodeID]>()
+                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[3],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1]],
                     replicateData,
                     setStale
                 )
-                manager.onNewContact({ nodeId: NODES_CLOSEST_TO_DATA[4], type: NodeType.NODEJS })
+                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
                 expect(setStale).toHaveBeenCalledTimes(0)

package/test/utils/customMatchers.ts

@@ -1,7 +1,8 @@
-import { areEqualBinaries, binaryToHex } from '@streamr/utils'
+import { areEqualBinaries } from '@streamr/utils'
 import { printExpected, printReceived } from 'jest-matcher-utils'
 import { isEqual } from 'lodash'
 import { ConnectivityMethod, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 // we could ES2015 module syntax (https://jestjs.io/docs/expect#expectextendmatchers),
 // but the IDE doesn't find custom matchers if we do that
@@ -24,7 +25,7 @@ const toEqualPeerDescriptor = (
 ): jest.CustomMatcherResult => {
     const messages: string[] = []
     if (!areEqualBinaries(expected.nodeId, actual.nodeId)) {
-        messages.push(formErrorMessage('nodeId', binaryToHex(expected.nodeId), binaryToHex(actual.nodeId)))
+        messages.push(formErrorMessage('nodeId', getDhtAddressFromRaw(expected.nodeId), getDhtAddressFromRaw(actual.nodeId)))
     }
     if (!isEqual(expected.type, actual.type)) {
         const typeNames = { [NodeType.NODEJS]: 'NODEJS', [NodeType.BROWSER]: 'BROWSER' }

package/test/utils/mock/mockDataEntry.ts

@@ -1,10 +1,10 @@
 import { MessageType as MessageType$, ScalarType } from '@protobuf-ts/runtime'
 import { randomString } from '@streamr/utils'
-import crypto from 'crypto'
 import { Timestamp } from '../../../src/proto/google/protobuf/timestamp'
 import { Any } from '../../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../../src/proto/packages/dht/protos/DhtRpc'
-import { createRandomNodeId } from '../../../src/helpers/nodeId'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../../src/identifiers'
+import { omit } from 'lodash'
 
 const MockData = new class extends MessageType$<{ foo: string }> {
     constructor() {
@@ -14,16 +14,18 @@ const MockData = new class extends MessageType$<{ foo: string }> {
     }
 }
 
-export const createMockDataEntry = (entry: Partial<DataEntry> = {}): DataEntry => {
+export const createMockDataEntry = (
+    entry: Partial<Omit<DataEntry, 'key' | 'creator'> & { key: DhtAddress, creator: DhtAddress }> = {}
+): DataEntry => {
     return { 
-        key: crypto.randomBytes(10),
+        key: getRawFromDhtAddress(entry.key ?? createRandomDhtAddress()),
         data: Any.pack({ foo: randomString(5) }, MockData),
-        creator: entry.creator ?? createRandomNodeId(),
+        creator: getRawFromDhtAddress(entry.creator ?? createRandomDhtAddress()),
         ttl: 10000,
         stale: false,
         deleted: false,
         createdAt: Timestamp.now(),
-        ...entry
+        ...omit(entry, 'key', 'creator')
     }
 }
 

package/test/utils/utils.ts

@@ -28,11 +28,11 @@ import { Empty } from '../../src/proto/google/protobuf/empty'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { wait, waitForCondition } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { createRandomNodeId } from '../../src/helpers/nodeId'
+import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 export const createMockPeerDescriptor = (opts?: Partial<Omit<PeerDescriptor, 'nodeId'>>): PeerDescriptor => {
     return {
-        nodeId: createRandomNodeId(),
+        nodeId: getRawFromDhtAddress(createRandomDhtAddress()),
         type: NodeType.NODEJS,
         ...opts
     }
@@ -40,13 +40,13 @@ export const createMockPeerDescriptor = (opts?: Partial<Omit<PeerDescriptor, 'no
 
 export const createMockConnectionDhtNode = async (
     simulator: Simulator,
-    nodeId?: Uint8Array,
+    nodeId?: DhtAddress,
     numberOfNodesPerKBucket?: number,
     maxConnections = 80,
     dhtJoinTimeout = 45000
 ): Promise<DhtNode> => {
     const peerDescriptor: PeerDescriptor = {
-        nodeId: nodeId ?? createRandomNodeId(),
+        nodeId: getRawFromDhtAddress(nodeId ?? createRandomDhtAddress()),
         type: NodeType.NODEJS,
         region: getRandomRegion()
     }

package/dist/src/helpers/nodeId.d.ts

@@ -1,6 +0,0 @@
-import { BrandedString } from '@streamr/utils';
-export declare const createRandomNodeId: () => Uint8Array;
-export type NodeID = BrandedString<'NodeID'>;
-export declare const areEqualNodeIds: (nodeId1: NodeID, nodeId2: NodeID) => boolean;
-export declare const getNodeIdFromDataKey: (key: Uint8Array) => NodeID;
-export declare const getNodeIdFromBinary: (id: Uint8Array) => NodeID;

package/dist/src/helpers/nodeId.js

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNodeIdFromBinary = exports.getNodeIdFromDataKey = exports.areEqualNodeIds = exports.createRandomNodeId = void 0;
-const utils_1 = require("@streamr/utils");
-const crypto_1 = __importDefault(require("crypto"));
-// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
-const KADEMLIA_ID_LENGTH_IN_BYTES = 20;
-// TODO this should return NodeID
-const createRandomNodeId = () => {
-    return crypto_1.default.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES);
-};
-exports.createRandomNodeId = createRandomNodeId;
-// TODO remove this or add support for UInt8Array parameters
-const areEqualNodeIds = (nodeId1, nodeId2) => {
-    return nodeId1 === nodeId2;
-};
-exports.areEqualNodeIds = areEqualNodeIds;
-// TODO maybe this is not needed and we can use just getNodeIdFromBinary?
-const getNodeIdFromDataKey = (key) => {
-    return (0, exports.getNodeIdFromBinary)(key);
-};
-exports.getNodeIdFromDataKey = getNodeIdFromDataKey;
-// TODO should we have similar method to convert nodeId to bucketId (which is just hexToBinary)
-const getNodeIdFromBinary = (id) => {
-    return (0, utils_1.binaryToHex)(id);
-};
-exports.getNodeIdFromBinary = getNodeIdFromBinary;
-//# sourceMappingURL=nodeId.js.map

package/dist/src/helpers/nodeId.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeId.js","sourceRoot":"","sources":["../../../src/helpers/nodeId.ts"],"names":[],"mappings":";;;;;;AAAA,0CAA2D;AAC3D,oDAA2B;AAE3B,wDAAwD;AACxD,MAAM,2BAA2B,GAAG,EAAE,CAAA;AAEtC,iCAAiC;AAC1B,MAAM,kBAAkB,GAAG,GAAe,EAAE;IAC/C,OAAO,gBAAM,CAAC,WAAW,CAAC,2BAA2B,CAAC,CAAA;AAC1D,CAAC,CAAA;AAFY,QAAA,kBAAkB,sBAE9B;AAKD,4DAA4D;AACrD,MAAM,eAAe,GAAG,CAAC,OAAe,EAAE,OAAe,EAAW,EAAE;IACzE,OAAO,OAAO,KAAK,OAAO,CAAA;AAC9B,CAAC,CAAA;AAFY,QAAA,eAAe,mBAE3B;AAED,yEAAyE;AAClE,MAAM,oBAAoB,GAAG,CAAC,GAAe,EAAU,EAAE;IAC5D,OAAO,IAAA,2BAAmB,EAAC,GAAG,CAAC,CAAA;AACnC,CAAC,CAAA;AAFY,QAAA,oBAAoB,wBAEhC;AAED,+FAA+F;AACxF,MAAM,mBAAmB,GAAG,CAAC,EAAc,EAAU,EAAE;IAC1D,OAAO,IAAA,mBAAW,EAAC,EAAE,CAAsB,CAAA;AAC/C,CAAC,CAAA;AAFY,QAAA,mBAAmB,uBAE/B"}

package/src/helpers/nodeId.ts

@@ -1,28 +0,0 @@
-import { BrandedString, binaryToHex } from '@streamr/utils'
-import crypto from 'crypto'
-
-// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
-const KADEMLIA_ID_LENGTH_IN_BYTES = 20
-
-// TODO this should return NodeID
-export const createRandomNodeId = (): Uint8Array => {
-    return crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES)
-}
-
-// TODO rename the file to be "NodeID.ts" instead of "nodeId.ts"
-export type NodeID = BrandedString<'NodeID'>
-
-// TODO remove this or add support for UInt8Array parameters
-export const areEqualNodeIds = (nodeId1: NodeID, nodeId2: NodeID): boolean => {
-    return nodeId1 === nodeId2
-}
-
-// TODO maybe this is not needed and we can use just getNodeIdFromBinary?
-export const getNodeIdFromDataKey = (key: Uint8Array): NodeID => {
-    return getNodeIdFromBinary(key)
-}
-
-// TODO should we have similar method to convert nodeId to bucketId (which is just hexToBinary)
-export const getNodeIdFromBinary = (id: Uint8Array): NodeID => {
-    return binaryToHex(id) as unknown as NodeID
-}