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

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()
         }

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)
         })
     })