@streamr/dht 101.1.2 → 102.0.0-beta.1

package/test/integration/GeoIpConnectivityChecking.test.ts

@@ -8,12 +8,12 @@ import { LOCAL_PROTOCOL_VERSION } from '../../src/helpers/version'
 import { WebsocketServerConnection } from '../../src/connection/websocket/WebsocketServerConnection'
 import fs from 'fs'
 
-// www.gov.za
-const testIp = '164.151.129.20'
+// helsinki.fi
+const testIp = '128.214.222.50'
 
-// Pretoria, South Africa
-const testLatitude = -25.7599
-const testLongitude = 28.2604
+// Helsinki, Finland
+const testLatitude = 60.1719
+const testLongitude = 24.9347
 
 const dbPath = '/tmp/geoipdatabasesintegration'
 
@@ -43,7 +43,8 @@ describe('ConnectivityChecking', () => {
                 transport: new MockTransport(),
                 geoIpDatabaseFolder: dbPath
             }),
-            metricsContext: new MetricsContext()
+            metricsContext: new MetricsContext(),
+            allowIncomingPrivateConnections: false
         })
         await server.start()
         mock = jest.spyOn(WebsocketServerConnection.prototype, 'getRemoteIpAddress').mockImplementation(() => testIp)
@@ -64,7 +65,7 @@ describe('ConnectivityChecking', () => {
             allowSelfSignedCertificate: false
         }
         const response = await sendConnectivityRequest(request, server.getLocalPeerDescriptor())
-        expect(response.version).toEqual(LOCAL_PROTOCOL_VERSION)
+        expect(response.protocolVersion).toEqual(LOCAL_PROTOCOL_VERSION)
         expect(response.latitude).toEqual(testLatitude)
         expect(response.longitude).toEqual(testLongitude)
     })

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

@@ -1,6 +1,6 @@
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { toDhtAddress } from '../../src/identifiers'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node, createMockPeerDescriptor } from '../utils/utils'
 
 const NODE_COUNT = 48
@@ -16,7 +16,7 @@ describe('Layer1', () => {
 
     beforeEach(async () => {
         simulator = new Simulator()
-        layer0EntryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(entryPoint0Descriptor.nodeId))
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, toDhtAddress(entryPoint0Descriptor.nodeId))
         await layer0EntryPoint.joinDht([entryPoint0Descriptor])
 
         nodes = []
@@ -178,7 +178,7 @@ describe('Layer1', () => {
     //         })
     //     })
     //
-    //     await waitForCondition(() => {
+    //     await until(() => {
     //         return [...receivedMessages.values()].every((set) => {
     //             return set.size === receivedMessages.size - 1
     //         })

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

@@ -2,7 +2,7 @@ import { Logger } from '@streamr/utils'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, createMockConnectionLayer1Node } from '../utils/utils'
-import { createRandomDhtAddress } from '../../src/identifiers'
+import { randomDhtAddress } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -22,11 +22,11 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
     beforeEach(async () => {
 
-        layer0EntryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
-        layer0Node1 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
-        layer0Node2 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
-        layer0Node3 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
-        layer0Node4 = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        layer0EntryPoint = await createMockConnectionDhtNode(simulator, randomDhtAddress())
+        layer0Node1 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
+        layer0Node2 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
+        layer0Node3 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
+        layer0Node4 = await createMockConnectionDhtNode(simulator, randomDhtAddress())
 
         layer1EntryPoint = await createMockConnectionLayer1Node(layer0EntryPoint)
 

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 
 describe('multiple entry point joining', () => {

package/test/integration/ReplicateData.test.ts

@@ -1,12 +1,11 @@
-/* eslint-disable no-console */
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, waitForStableTopology } from '../utils/utils'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { DhtAddress, createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, randomDhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
 import { sample } from 'lodash'
-import { DataEntry, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DataEntry, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 
 const DATA = createMockDataEntry()
 const NUM_NODES = 100
@@ -17,7 +16,7 @@ const ENTRY_POINT_INDEX = 0
 const getDataEntries = (node: DhtNode): DataEntry[] => {
     // @ts-expect-error private field
     const store = node.localDataStore
-    return Array.from(store.values(getDhtAddressFromRaw(DATA.key)))
+    return Array.from(store.values(toDhtAddress(DATA.key)))
 }
 
 describe('Replicate data from node to node in DHT', () => {
@@ -27,7 +26,7 @@ describe('Replicate data from node to node in DHT', () => {
     const simulator = new Simulator(LatencyType.FIXED, 20)
 
     beforeEach(async () => {
-        const entryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress(), K, MAX_CONNECTIONS)
+        const entryPoint = await createMockConnectionDhtNode(simulator, randomDhtAddress(), K, MAX_CONNECTIONS)
         entryPointDescriptor = entryPoint.getLocalPeerDescriptor()
         await entryPoint.joinDht([entryPointDescriptor])
         nodes = []
@@ -35,7 +34,7 @@ describe('Replicate data from node to node in DHT', () => {
         for (let i = 1; i < NUM_NODES; i++) {
             const node = await createMockConnectionDhtNode(
                 simulator,
-                createRandomDhtAddress(),
+                randomDhtAddress(),
                 K,
                 MAX_CONNECTIONS
             )
@@ -54,14 +53,14 @@ describe('Replicate data from node to node in DHT', () => {
     it('Data replicates to the closest node no matter where it is stored', async () => {
         // calculate offline which node is closest to the data
         const sortedList = new SortedContactList<DhtNode>({ 
-            referenceId: getDhtAddressFromRaw(DATA.key),
+            referenceId: toDhtAddress(DATA.key),
             maxSize: 10000, 
             allowToContainReferenceId: true
         })
         nodes.forEach((node) => sortedList.addContact(node))
 
         const closest = sortedList.getClosestContacts()
-        const successfulStorers = await nodes[0].storeDataToDht(getDhtAddressFromRaw(DATA.key), DATA.data!)
+        const successfulStorers = await nodes[0].storeDataToDht(toDhtAddress(DATA.key), DATA.data!)
         expect(successfulStorers.length).toBe(1)
 
         await Promise.all(
@@ -89,16 +88,16 @@ describe('Replicate data from node to node in DHT', () => {
         await waitForStableTopology(nodes)
 
         const randomIndex = Math.floor(Math.random() * nodes.length)
-        const storerDescriptors = await nodes[randomIndex].storeDataToDht(getDhtAddressFromRaw(DATA.key), DATA.data!)
+        const storerDescriptors = await nodes[randomIndex].storeDataToDht(toDhtAddress(DATA.key), DATA.data!)
         const stoppedNodeIds: DhtAddress[] = []
         await Promise.all(storerDescriptors.map(async (storerDescriptor) => {
-            const storer = nodes.find((n) => n.getNodeId() === getNodeIdFromPeerDescriptor(storerDescriptor))!
+            const storer = nodes.find((n) => n.getNodeId() === toNodeId(storerDescriptor))!
             await storer.stop()
             stoppedNodeIds.push(storer.getNodeId())
         }))
 
         const randomNonStoppedNode = sample(nodes.filter((n) => !stoppedNodeIds.includes(n.getNodeId())))!
-        const data = await randomNonStoppedNode.fetchDataFromDht(getDhtAddressFromRaw(DATA.key))
+        const data = await randomNonStoppedNode.fetchDataFromDht(toDhtAddress(DATA.key))
         expect(data).toHaveLength(1)
         expectEqualData(data[0], DATA)
     }, 180000)

package/test/integration/RouteMessage.test.ts

@@ -1,13 +1,13 @@
 import { DhtNode, Events as DhtNodeEvents } from '../../src/dht/DhtNode'
-import { Message, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, runAndWaitForEvents3, waitForCondition } from '@streamr/utils'
+import { Message, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
+import { Logger, runAndWaitForEvents3, until } from '@streamr/utils'
 import { createMockConnectionDhtNode, createWrappedClosestPeersRequest } from '../utils/utils'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { v4 } from 'uuid'
-import { Any } from '../../src/proto/google/protobuf/any'
+import { Any } from '../../generated/google/protobuf/any'
 import { RoutingMode } from '../../src/dht/routing/RoutingSession'
-import { DhtAddress, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { DhtAddress, randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
 
 const logger = new Logger(module)
 
@@ -25,18 +25,18 @@ describe('Route Message With Mock Connections', () => {
     beforeEach(async () => {
         routerNodes = []
         simulator = new Simulator()
-        entryPoint = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        entryPoint = await createMockConnectionDhtNode(simulator, randomDhtAddress())
 
         entryPointDescriptor = {
-            nodeId: getRawFromDhtAddress(entryPoint.getNodeId()),
+            nodeId: toDhtAddressRaw(entryPoint.getNodeId()),
             type: NodeType.NODEJS
         }
 
-        sourceNode = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
-        destinationNode = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+        sourceNode = await createMockConnectionDhtNode(simulator, randomDhtAddress())
+        destinationNode = await createMockConnectionDhtNode(simulator, randomDhtAddress())
 
         for (let i = 1; i < NUM_NODES; i++) {
-            const node = await createMockConnectionDhtNode(simulator, createRandomDhtAddress())
+            const node = await createMockConnectionDhtNode(simulator, randomDhtAddress())
             routerNodes.push(node)
         }
 
@@ -116,7 +116,7 @@ describe('Route Message With Mock Connections', () => {
                 parallelRootNodeIds: []
             })
         }
-        await waitForCondition(() => receivedMessages === messageCount)
+        await until(() => receivedMessages === messageCount)
     })
 
     it('From all to all', async () => {
@@ -157,10 +157,10 @@ describe('Route Message With Mock Connections', () => {
                 }))
             )
         )
-        await waitForCondition(() => receivedMessageCounts[routerNodes[0].getNodeId()] >= routerNodes.length - 1, 30000)
+        await until(() => receivedMessageCounts[routerNodes[0].getNodeId()] >= routerNodes.length - 1, 30000)
         await Promise.all(
             Object.keys(receivedMessageCounts).map(async (key) =>
-                waitForCondition(() => receivedMessageCounts[key as DhtAddress] >= routerNodes.length - 1, 30000)
+                until(() => receivedMessageCounts[key as DhtAddress] >= routerNodes.length - 1, 30000)
             )
         )
 

package/test/integration/RouterRpcRemote.test.ts

@@ -1,8 +1,8 @@
 import { RpcCommunicator } from '@streamr/proto-rpc'
 import { RouterRpcRemote } from '../../src/dht/routing/RouterRpcRemote'
-import { Message, RouteMessageAck, RouteMessageWrapper } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RouterRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message, RouteMessageAck, RouteMessageWrapper } from '../../generated/packages/dht/protos/DhtRpc'
+import { RouterRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest, mockRouterRpc } from '../utils/utils'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
@@ -20,11 +20,11 @@ describe('RemoteRouter', () => {
         clientRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage', mockRouterRpc.routeMessage)
-        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
-            serverRpcCommunicator.handleIncomingMessage(message)
+        clientRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
+            serverRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
         })
-        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
-            clientRpcCommunicator.handleIncomingMessage(message)
+        serverRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
+            clientRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
         })
         remoteRouter = new RouterRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, RouterRpcClient)
     })

package/test/integration/SimultaneousConnections.test.ts

@@ -1,14 +1,14 @@
-import { MetricsContext, waitForCondition } from '@streamr/utils'
+import { MetricsContext, until } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
-import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { MockTransport } from '../utils/mock/MockTransport'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const BASE_MESSAGE: Message = {
     serviceId: 'serviceId',
@@ -25,7 +25,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, opts: Omit
             createLocalPeerDescriptor: async () => localPeerDescriptor,
             ...opts
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     })
 }
 
@@ -78,8 +79,8 @@ describe('SimultaneousConnections', () => {
             simTransport1.send(msg1),
             simTransport2.send(msg2)
         ])
-        await waitForCondition(() => simTransport2.hasConnection(getNodeIdFromPeerDescriptor(peerDescriptor1)))
-        await waitForCondition(() => simTransport1.hasConnection(getNodeIdFromPeerDescriptor(peerDescriptor2)))
+        await until(() => simTransport2.hasConnection(toNodeId(peerDescriptor1)))
+        await until(() => simTransport1.hasConnection(toNodeId(peerDescriptor2)))
     })
 
     describe('Websocket 2 servers', () => {
@@ -159,8 +160,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor2)))
-            await waitForCondition(() => connectionManager2.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor1)))
+            await until(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
+            await until(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
         })
     })
 
@@ -239,8 +240,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor2)))
-            await waitForCondition(() => connectionManager2.hasConnection(getNodeIdFromPeerDescriptor(wsPeerDescriptor1)))
+            await until(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
+            await until(() => connectionManager2.hasConnection(toNodeId(wsPeerDescriptor1)))
         })
     })
 
@@ -307,8 +308,8 @@ describe('SimultaneousConnections', () => {
                 connectionManager2.send(msg2)
             ])
 
-            await waitForCondition(() => connectionManager1.hasConnection(getNodeIdFromPeerDescriptor(wrtcPeerDescriptor2)))
-            await waitForCondition(() => connectionManager2.hasConnection(getNodeIdFromPeerDescriptor(wrtcPeerDescriptor1)))
+            await until(() => connectionManager1.hasConnection(toNodeId(wrtcPeerDescriptor2)))
+            await until(() => connectionManager2.hasConnection(toNodeId(wrtcPeerDescriptor1)))
         })
     })
 

package/test/integration/Store.test.ts

@@ -1,7 +1,7 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { toDhtAddress, toNodeId } from '../../src/identifiers'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { createMockConnectionDhtNode, createMockPeerDescriptor, waitForStableTopology } from '../utils/utils'
 
@@ -44,7 +44,7 @@ describe('Storing data in DHT', () => {
         const storingNodeIndex = 34
         const entry = createMockDataEntry()
         const successfulStorers = await nodes[storingNodeIndex].storeDataToDht(
-            getDhtAddressFromRaw(entry.key),
+            toDhtAddress(entry.key),
             entry.data!
         )
         expect(successfulStorers.length).toBeGreaterThan(4)
@@ -54,12 +54,12 @@ describe('Storing data in DHT', () => {
         const storingNode = getRandomNode()
         const entry = createMockDataEntry()
         const successfulStorers = await storingNode.storeDataToDht(
-            getDhtAddressFromRaw(entry.key),
+            toDhtAddress(entry.key),
             entry.data!
         )
         expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
         results.forEach((result) => {
             expectEqualData(result, entry)
         })
@@ -70,16 +70,16 @@ describe('Storing data in DHT', () => {
         const entry = createMockDataEntry()
         const requestor = createMockPeerDescriptor()
         const successfulStorers = await storingNode.storeDataToDht(
-            getDhtAddressFromRaw(entry.key),
+            toDhtAddress(entry.key),
             entry.data!,
-            getDhtAddressFromRaw(requestor.nodeId)
+            toDhtAddress(requestor.nodeId)
         )
         expect(successfulStorers.length).toBeGreaterThan(4)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
         results.forEach((result) => {
             expectEqualData(result, entry)
-            expect(getDhtAddressFromRaw(result.creator)).toEqual(getNodeIdFromPeerDescriptor(requestor))
+            expect(toDhtAddress(result.creator)).toEqual(toNodeId(requestor))
         })
     }, 30000)
 })

package/test/integration/StoreAndDelete.test.ts

@@ -2,7 +2,7 @@ import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator
 import { DhtNode } from '../../src/dht/DhtNode'
 import { createMockConnectionDhtNode, waitForStableTopology } from '../utils/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
+import { randomDhtAddress, toDhtAddress } from '../../src/identifiers'
 import { wait } from '@streamr/utils'
 
 const NUM_NODES = 5
@@ -21,7 +21,7 @@ describe('Storing data in DHT', () => {
     beforeEach(async () => {
         nodes = []
         const entryPoint = await createMockConnectionDhtNode(simulator,
-            createRandomDhtAddress(), K, MAX_CONNECTIONS)
+            randomDhtAddress(), K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const node = await createMockConnectionDhtNode(simulator, 
@@ -39,13 +39,13 @@ describe('Storing data in DHT', () => {
     it('Data can be deleted', async () => {
         const storingNode = getRandomNode()
         const entry = createMockDataEntry()
-        const successfulStorers = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
+        const successfulStorers = await storingNode.storeDataToDht(toDhtAddress(entry.key), entry.data!)
         expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(getDhtAddressFromRaw(entry.key), true)
+        await storingNode.deleteDataFromDht(toDhtAddress(entry.key), true)
         // Wait for the delete operation to propagate
         await wait(500)
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
         results.forEach((result) => {
             expect(result.deleted).toBeTrue()
             expectEqualData(result, entry)
@@ -55,20 +55,20 @@ 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(getDhtAddressFromRaw(entry.key), entry.data!)
+        const successfulStorers1 = await storingNode.storeDataToDht(toDhtAddress(entry.key), entry.data!)
         expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(getDhtAddressFromRaw(entry.key), true)
+        await storingNode.deleteDataFromDht(toDhtAddress(entry.key), true)
         // Wait for the delete operation to propagate
         await wait(500)
         const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results1 = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
         results1.forEach((result) => {
             expect(result.deleted).toBeTrue()
             expectEqualData(result, entry)
         })
-        const successfulStorers2 = await storingNode.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
+        const successfulStorers2 = await storingNode.storeDataToDht(toDhtAddress(entry.key), entry.data!)
         expect(successfulStorers2.length).toBeGreaterThan(4)
-        const results2 = await fetchingNode.fetchDataFromDht(getDhtAddressFromRaw(entry.key))
+        const results2 = await fetchingNode.fetchDataFromDht(toDhtAddress(entry.key))
         results2.forEach((result) => {
             expect(result.deleted).toBeFalse()
             expectEqualData(result, entry)

package/test/integration/StoreOnDhtWithThreeNodes.test.ts

@@ -2,7 +2,7 @@ import { createMockConnectionDhtNode } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { toDhtAddress } from '../../src/identifiers'
 
 describe('Storing data in DHT with two peers', () => {
 
@@ -34,22 +34,22 @@ describe('Storing data in DHT with two peers', () => {
         await entryPoint.stop()
         await node1.stop()
         await node2.stop()
-        simulator?.stop()
+        simulator!.stop()
     })
 
     it('Node can store on three peer DHT', async () => {
         const storedData1 = createMockDataEntry()
         const storedData2 = createMockDataEntry()
         // Here we effectively test that fetching "null" data doesn't take too long. A test timeout here indicates an issue. 
-        await node1.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
-        await node2.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        await node1.fetchDataFromDht(toDhtAddress(storedData1.key))
+        await node2.fetchDataFromDht(toDhtAddress(storedData1.key))
         
-        await node1.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
-        await node2.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
-        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData2.key), storedData2.data!)
-        const foundData1 = await node1.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
-        const foundData2 = await node2.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
-        const foundData3 = await entryPoint.fetchDataFromDht(getDhtAddressFromRaw(storedData2.key))
+        await node1.storeDataToDht(toDhtAddress(storedData1.key), storedData1.data!)
+        await node2.storeDataToDht(toDhtAddress(storedData1.key), storedData1.data!)
+        await entryPoint.storeDataToDht(toDhtAddress(storedData2.key), storedData2.data!)
+        const foundData1 = await node1.fetchDataFromDht(toDhtAddress(storedData1.key))
+        const foundData2 = await node2.fetchDataFromDht(toDhtAddress(storedData1.key))
+        const foundData3 = await entryPoint.fetchDataFromDht(toDhtAddress(storedData2.key))
         expectEqualData(foundData1[0], storedData1)
         expectEqualData(foundData1[1], storedData1)
         expectEqualData(foundData2[0], storedData1)

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,9 +1,9 @@
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { toDhtAddress } from '../../src/identifiers'
 
 describe('Storing data in DHT with two peers', () => {
 
@@ -26,26 +26,26 @@ describe('Storing data in DHT with two peers', () => {
     afterEach(async () => {
         await entryPoint.stop()
         await otherNode.stop()
-        simulator?.stop()
+        simulator!.stop()
     })
 
     it('Node can store on two peer DHT', async () => {
         const storedData1 = createMockDataEntry()
         const storedData2 = createMockDataEntry()
-        await otherNode.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
-        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData2.key), storedData2.data!)
-        const foundData1 = await otherNode.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
-        const foundData2 = await entryPoint.fetchDataFromDht(getDhtAddressFromRaw(storedData2.key))
+        await otherNode.storeDataToDht(toDhtAddress(storedData1.key), storedData1.data!)
+        await entryPoint.storeDataToDht(toDhtAddress(storedData2.key), storedData2.data!)
+        const foundData1 = await otherNode.fetchDataFromDht(toDhtAddress(storedData1.key))
+        const foundData2 = await entryPoint.fetchDataFromDht(toDhtAddress(storedData2.key))
         expectEqualData(foundData1[0], storedData1)
         expectEqualData(foundData2[0], storedData2)
     })
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
-        await waitForCondition(() => entryPoint.getNeighborCount() === 0)
+        await until(() => entryPoint.getNeighborCount() === 0)
         const storedData = createMockDataEntry()
-        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData.key), storedData.data!)
-        const foundData = await entryPoint.fetchDataFromDht(getDhtAddressFromRaw(storedData.key))
+        await entryPoint.storeDataToDht(toDhtAddress(storedData.key), storedData.data!)
+        const foundData = await entryPoint.fetchDataFromDht(toDhtAddress(storedData.key))
         expectEqualData(foundData[0], storedData)
     }, 60000)
 })

package/test/integration/StoreRpcRemote.test.ts

@@ -2,14 +2,14 @@ import { RpcCommunicator } from '@streamr/proto-rpc'
 import {
     StoreDataRequest,
     StoreDataResponse
-} from '../../src/proto/packages/dht/protos/DhtRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor, mockStoreRpc } from '../utils/utils'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { StoreRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
+import { StoreRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { StoreRpcRemote } from '../../src/dht/store/StoreRpcRemote'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-import { createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+import { randomDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
 
 describe('StoreRpcRemote', () => {
 
@@ -22,7 +22,7 @@ describe('StoreRpcRemote', () => {
     const request: StoreDataRequest = {
         key: data.key,
         data: data.data,
-        creator: getRawFromDhtAddress(createRandomDhtAddress()),
+        creator: toDhtAddressRaw(randomDhtAddress()),
         ttl: 10
     }
 
@@ -30,11 +30,11 @@ describe('StoreRpcRemote', () => {
         clientRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.storeData)
-        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
-            serverRpcCommunicator.handleIncomingMessage(message)
+        clientRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
+            serverRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
         })
-        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
-            clientRpcCommunicator.handleIncomingMessage(message)
+        serverRpcCommunicator.setOutgoingMessageListener(async (message: RpcMessage) => {
+            clientRpcCommunicator.handleIncomingMessage(message, new DhtCallContext())
         })
         rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, StoreRpcClient)
     })
@@ -45,9 +45,9 @@ describe('StoreRpcRemote', () => {
 
     it('storeData rejects', async () => {
         serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
-        await expect(rpcRemote.storeData(request)).rejects.toThrowError(
+        await expect(rpcRemote.storeData(request)).rejects.toThrow(
             'Could not store data to'
-            + ` ${getNodeIdFromPeerDescriptor(serverPeerDescriptor)} from ${getNodeIdFromPeerDescriptor(clientPeerDescriptor)}`
+            + ` ${toNodeId(serverPeerDescriptor)} from ${toNodeId(clientPeerDescriptor)}`
             + ' Error: Mock'
         )
     })