@streamr/dht 101.1.2 → 102.0.0-beta.1

package/test/end-to-end/Layer0Webrtc.test.ts

@@ -1,9 +1,9 @@
 import { areEqualBinaries, waitForEvent3 } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/exports'
+import { toNodeId } from '../../src/exports'
 
 describe('Layer0 with WebRTC connections', () => {
 
@@ -64,8 +64,8 @@ describe('Layer0 with WebRTC connections', () => {
             node2.joinDht([epPeerDescriptor]),
             node1.joinDht([epPeerDescriptor])
         ])
-        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
-        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        const nodeId1 = toNodeId(node1.getLocalPeerDescriptor())
+        const nodeId2 = toNodeId(node2.getLocalPeerDescriptor())
         expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
     }, 60000)
@@ -77,8 +77,8 @@ describe('Layer0 with WebRTC connections', () => {
             node3.joinDht([epPeerDescriptor]),
             node4.joinDht([epPeerDescriptor])
         ])
-        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
-        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        const nodeId1 = toNodeId(node1.getLocalPeerDescriptor())
+        const nodeId2 = toNodeId(node2.getLocalPeerDescriptor())
         expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
     })

package/test/end-to-end/RecoveryFromFailedAutoCertification.test.ts

@@ -1,5 +1,5 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import os from 'os'
 
 describe('Failed autocertification', () => {

package/test/end-to-end/WebsocketConnectionRequest.test.ts

@@ -1,7 +1,7 @@
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { areEqualPeerDescriptors } from '../../src/identifiers'
 
@@ -60,7 +60,7 @@ describe('Websocket IConnection Requests', () => {
         await node2.joinDht([epPeerDescriptor])
         await node1.joinDht([epPeerDescriptor])
 
-        await waitForCondition(() => { return (connected1 && connected2) })
+        await until(() => { return (connected1 && connected2) })
 
         expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getNodeId())).toEqual(true)
         expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getNodeId())).toEqual(true)

package/test/end-to-end/memory-leak.test.ts

@@ -1,10 +1,10 @@
 import LeakDetector from 'jest-leak-detector'
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { Message } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const MESSAGE_ID = 'mock-message-id'
 
@@ -19,7 +19,7 @@ describe('memory leak', () => {
             }
         })
         let entryPoint: DhtNode | undefined = new DhtNode({
-            nodeId: getNodeIdFromPeerDescriptor(entryPointDescriptor),
+            nodeId: toNodeId(entryPointDescriptor),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
                 min: entryPointDescriptor.websocket!.port,
@@ -55,7 +55,7 @@ describe('memory leak', () => {
             }
         }
         await sender.send(msg)
-        await waitForCondition(() => receivedMessage !== undefined)
+        await until(() => receivedMessage !== undefined)
         expect(receivedMessage!.messageId).toEqual(MESSAGE_ID)
 
         await Promise.all([

package/test/integration/ConnectionLocking.test.ts

@@ -1,13 +1,13 @@
-import { MetricsContext, waitForCondition } from '@streamr/utils'
+import { MetricsContext, until } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { ITransport } from '../../src/transport/ITransport'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -15,7 +15,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
             transport,
             createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: true
     })
 }
 
@@ -56,10 +57,11 @@ describe('Connection Locking', () => {
     })
 
     it('can lock connections', async () => {
-        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
-        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
+        const nodeId1 = toNodeId(mockPeerDescriptor1)
+        const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
         expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
@@ -68,14 +70,16 @@ describe('Connection Locking', () => {
     })
 
     it('Multiple services on the same peer', async () => {
-        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
-        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
+        const nodeId1 = toNodeId(mockPeerDescriptor1)
+        const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
         expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
@@ -84,35 +88,38 @@ describe('Connection Locking', () => {
     })
 
     it('can unlock connections', async () => {
-        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
-        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
+        const nodeId1 = toNodeId(mockPeerDescriptor1)
+        const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
         ])
-        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
         expect(connectionManager2.hasLocalLockedConnection(nodeId2)).toEqual(false)
         expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock')
         expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(false)
-        await waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
+        await until(() => connectionManager2.hasRemoteLockedConnection(nodeId1) === false)
         expect(connectionManager1.hasConnection(nodeId1)).toEqual(false)
     })
 
     it('unlocking multiple services', async () => {
-        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
-        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
+        const nodeId1 = toNodeId(mockPeerDescriptor1)
+        const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
         ])
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock2')
         ])
 
-        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
         expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(false)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
@@ -124,20 +131,22 @@ describe('Connection Locking', () => {
     })
 
     it('maintains connection if both sides initially lock and then one end unlocks', async () => {
-        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
-        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
+        const nodeId1 = toNodeId(mockPeerDescriptor1)
+        const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
 
-        expect(connectionManager1.hasLocalLockedConnection(nodeId2))
-        expect(connectionManager2.hasLocalLockedConnection(nodeId1))
+        expect(connectionManager1.hasLocalLockedConnection(nodeId2)).toEqual(true)
+        expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
 
         connectionManager1.unlockConnection(mockPeerDescriptor2, 'testLock1')
-        await waitForCondition(() =>
+        await until(() =>
             connectionManager1.hasRemoteLockedConnection(nodeId2)
             && !connectionManager1.hasLocalLockedConnection(nodeId2)
             && !connectionManager2.hasRemoteLockedConnection(nodeId1)
@@ -149,31 +158,33 @@ describe('Connection Locking', () => {
     })
 
     it('unlocks after graceful disconnect', async () => {
-        const nodeId1 = getNodeIdFromPeerDescriptor(mockPeerDescriptor1)
-        const nodeId2 = getNodeIdFromPeerDescriptor(mockPeerDescriptor2)
+        const nodeId1 = toNodeId(mockPeerDescriptor1)
+        const nodeId2 = toNodeId(mockPeerDescriptor2)
         await Promise.all([
-            waitForCondition(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
-            waitForCondition(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            until(() => connectionManager2.hasRemoteLockedConnection(nodeId1)),
+            until(() => connectionManager1.hasRemoteLockedConnection(nodeId2)),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1'),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             connectionManager2.lockConnection(mockPeerDescriptor1, 'testLock1')
         ])
-        expect(connectionManager1.hasConnection(nodeId2))
+        expect(connectionManager1.hasConnection(nodeId2)).toEqual(true)
         expect(connectionManager2.hasLocalLockedConnection(nodeId1)).toEqual(true)
         expect(connectionManager2.hasRemoteLockedConnection(nodeId1)).toEqual(true)
 
         //@ts-expect-error private field
         await connectionManager1.gracefullyDisconnectAsync(mockPeerDescriptor2)
         
-        await waitForCondition(() =>
+        await until(() =>
             !connectionManager1.hasRemoteLockedConnection(nodeId2)
             && !connectionManager1.hasLocalLockedConnection(nodeId2)
         )
-        await waitForCondition(() =>
+        await until(() =>
             !connectionManager2.hasRemoteLockedConnection(nodeId1)
             && !connectionManager2.hasLocalLockedConnection(nodeId1)
         )
-        await waitForCondition(() => !connectionManager2.hasConnection(nodeId1))
-        await waitForCondition(() => !connectionManager1.hasConnection(nodeId2))
+        await until(() => !connectionManager2.hasConnection(nodeId1))
+        await until(() => !connectionManager1.hasConnection(nodeId2))
 
         expect(connectionManager1.hasConnection(nodeId2)).toEqual(false)
         expect(connectionManager2.hasConnection(nodeId1)).toEqual(false)

package/test/integration/ConnectionManager.test.ts

@@ -1,13 +1,13 @@
-import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
+import { Logger, MetricsContext, until, waitForEvent3 } from '@streamr/utils'
 import { MarkOptional } from 'ts-essentials'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeOptions } from '../../src/connection/ConnectorFacade'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
-import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
-import { ConnectivityResponse, Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { randomDhtAddress, toDhtAddressRaw } from '../../src/identifiers'
+import { ConnectivityResponse, Message, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { TransportEvents } from '../../src/transport/ITransport'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
@@ -37,7 +37,8 @@ describe('ConnectionManager', () => {
                 websocketServerEnableTls: false,
                 ...opts
             }),
-            metricsContext: new MetricsContext()
+            metricsContext: new MetricsContext(),
+            allowIncomingPrivateConnections: true
         })
     }
 
@@ -383,7 +384,7 @@ describe('ConnectionManager', () => {
             messageId: '1',
             targetDescriptor: {
                 // This is not the correct nodeId of peerDescriptor2
-                nodeId: getRawFromDhtAddress(createRandomDhtAddress()),
+                nodeId: toDhtAddressRaw(randomDhtAddress()),
                 type: NodeType.NODEJS,
                 websocket: peerDescriptor2.websocket
             },
@@ -469,4 +470,59 @@ describe('ConnectionManager', () => {
         await connectionManager2.stop()
     })
 
+    it('private connections', async () => {
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            websocketServerEnableTls: false,
+            websocketPortRange: { min: 10009, max: 10009 }
+        })
+
+        await connectionManager1.start()
+
+        const connectionManager2 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            websocketServerEnableTls: false,
+            websocketPortRange: { min: 10010, max: 100010 }
+        })
+
+        await connectionManager2.start()
+
+        const msg: Message = {
+            serviceId: SERVICE_ID,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            targetDescriptor: connectionManager1.getLocalPeerDescriptor()
+        }
+
+        const connectedPromise1 = new Promise<void>((resolve, _reject) => {
+            connectionManager1.on('connected', () => {
+                resolve()
+            })
+        })
+
+        const connectedPromise2 = new Promise<void>((resolve, _reject) => {
+            connectionManager2.on('connected', () => {
+                resolve()
+            })
+        })
+        await Promise.all([connectedPromise1, connectedPromise2, connectionManager2.send(msg)])
+
+        await connectionManager1.enablePrivateClientMode()
+        await until(() => connectionManager2.getConnections().length === 0)
+        expect(connectionManager1.getConnections().length).toEqual(1)
+
+        await connectionManager1.disablePrivateClientMode()
+        await until(() => connectionManager2.getConnections().length === 1)
+        expect(connectionManager1.getConnections().length).toEqual(1)
+
+        await connectionManager1.stop()
+        await connectionManager2.stop()
+ 
+    })
+
 })

package/test/integration/ConnectivityChecking.test.ts

@@ -30,7 +30,8 @@ describe('ConnectivityChecking', () => {
                 websocketServerEnableTls: false,
                 transport: new MockTransport()
             }),
-            metricsContext: new MetricsContext()
+            metricsContext: new MetricsContext(),
+            allowIncomingPrivateConnections: false
         })
         await server.start()
     })
@@ -47,6 +48,6 @@ 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)
     })
 })

package/test/integration/DhtJoinPeerDiscovery.test.ts

@@ -1,7 +1,7 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { getRandomRegion } from '../../src/connection/simulator/pings'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { toDhtAddress } from '../../src/identifiers'
 import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 
 const NUM_OF_NODES_PER_KBUCKET = 8
@@ -11,7 +11,7 @@ const runTest = async (latencyType: LatencyType) => {
     const entrypointDescriptor = createMockPeerDescriptor({
         region: getRandomRegion()
     })
-    const entryPoint = await createMockConnectionDhtNode(simulator, getDhtAddressFromRaw(entrypointDescriptor.nodeId), NUM_OF_NODES_PER_KBUCKET)
+    const entryPoint = await createMockConnectionDhtNode(simulator, toDhtAddress(entrypointDescriptor.nodeId), NUM_OF_NODES_PER_KBUCKET)
     const nodes: DhtNode[] = []
     for (let i = 1; i < 100; i++) {
         const node = await createMockConnectionDhtNode(simulator, undefined, NUM_OF_NODES_PER_KBUCKET)

package/test/integration/DhtNode.test.ts

@@ -1,8 +1,8 @@
-import { waitForCondition } from '@streamr/utils'
+import { until } from '@streamr/utils'
 import { range, without } from 'lodash'
 import { DhtNodeRpcLocal } from '../../src/dht/DhtNodeRpcLocal'
-import { DhtNode, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '../../src/exports'
-import { ClosestPeersRequest, ClosestPeersResponse, PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNode, ListeningRpcCommunicator, toNodeId } from '../../src/exports'
+import { ClosestPeersRequest, ClosestPeersResponse, PeerDescriptor, PingRequest, PingResponse } from '../../generated/packages/dht/protos/DhtRpc'
 import { FakeEnvironment } from '../utils/FakeTransport'
 import { createMockPeerDescriptor } from '../utils/utils'
 
@@ -58,9 +58,9 @@ describe('DhtNode', () => {
         await localNode.joinDht([entryPointPeerDescriptor])
         await localNode.waitForNetworkConnectivity()
 
-        await waitForCondition(() => localNode.getNeighborCount() === otherPeerDescriptors.length + 1)
-        const expectedNodeIds = without(getAllPeerDescriptors(), localPeerDescriptor).map((n) => getNodeIdFromPeerDescriptor(n))
-        const actualNodeIds = localNode.getClosestContacts().map((n) => getNodeIdFromPeerDescriptor(n))
+        await until(() => localNode.getNeighborCount() === otherPeerDescriptors.length + 1)
+        const expectedNodeIds = without(getAllPeerDescriptors(), localPeerDescriptor).map((n) => toNodeId(n))
+        const actualNodeIds = localNode.getClosestContacts().map((n) => toNodeId(n))
         expect(actualNodeIds).toIncludeSameMembers(expectedNodeIds)
     })
 })

package/test/integration/DhtNodeExternalAPI.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { randomDhtAddress, toDhtAddress, toNodeId } from '../../src/identifiers'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
 import { createMockConnectionDhtNode } from '../utils/utils'
 
@@ -27,22 +27,22 @@ describe('DhtNodeExternalApi', () => {
 
     it('fetch data happy path', async () => {
         const entry = createMockDataEntry()
-        await dhtNode1.storeDataToDht(getDhtAddressFromRaw(entry.key), entry.data!)
-        const foundData = await remote.fetchDataFromDhtViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
+        await dhtNode1.storeDataToDht(toDhtAddress(entry.key), entry.data!)
+        const foundData = await remote.fetchDataFromDhtViaPeer(toDhtAddress(entry.key), dhtNode1.getLocalPeerDescriptor())
         expectEqualData(foundData[0], entry)
     })
     
     it('fetch data returns empty array if no data found', async () => {
-        const foundData = await remote.fetchDataFromDhtViaPeer(createRandomDhtAddress(), dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.fetchDataFromDhtViaPeer(randomDhtAddress(), dhtNode1.getLocalPeerDescriptor())
         expect(foundData).toEqual([])
     })
 
     it('external store data happy path', async () => {
         const entry = createMockDataEntry()
-        await remote.storeDataToDhtViaPeer(getDhtAddressFromRaw(entry.key), entry.data!, dhtNode1.getLocalPeerDescriptor())
-        const foundData = await remote.fetchDataFromDhtViaPeer(getDhtAddressFromRaw(entry.key), dhtNode1.getLocalPeerDescriptor())
+        await remote.storeDataToDhtViaPeer(toDhtAddress(entry.key), entry.data!, dhtNode1.getLocalPeerDescriptor())
+        const foundData = await remote.fetchDataFromDhtViaPeer(toDhtAddress(entry.key), dhtNode1.getLocalPeerDescriptor())
         expectEqualData(foundData[0], entry)
-        expect(getDhtAddressFromRaw(foundData[0].creator)).toEqual(getNodeIdFromPeerDescriptor(remote.getLocalPeerDescriptor()))
+        expect(toDhtAddress(foundData[0].creator)).toEqual(toNodeId(remote.getLocalPeerDescriptor()))
     })
   
 })

package/test/integration/DhtNodeRpcRemote.test.ts

@@ -6,10 +6,10 @@ import {
     ClosestPeersResponse,
     PingRequest,
     PingResponse
-} from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+} from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const SERVICE_ID = 'test'
 
@@ -27,11 +27,11 @@ describe('DhtNodeRpcRemote', () => {
         serverRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
         serverRpcCommunicator.registerRpcMethod(PingRequest, PingResponse, 'ping', mockDhtRpc.ping)
-        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 DhtNodeRpcRemote(clientPeerDescriptor, serverPeerDescriptor, SERVICE_ID, clientRpcCommunicator)
     })
@@ -47,7 +47,7 @@ describe('DhtNodeRpcRemote', () => {
     })
 
     it('getClosestPeers happy path', async () => {
-        const neighbors = await rpcRemote.getClosestPeers(getNodeIdFromPeerDescriptor(clientPeerDescriptor))
+        const neighbors = await rpcRemote.getClosestPeers(toNodeId(clientPeerDescriptor))
         expect(neighbors.length).toEqual(createMockPeers().length)
     })
 
@@ -59,7 +59,7 @@ describe('DhtNodeRpcRemote', () => {
 
     it('getClosestPeers error path', async () => {
         serverRpcCommunicator.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.throwGetClosestPeersError)
-        await expect(rpcRemote.getClosestPeers(getNodeIdFromPeerDescriptor(clientPeerDescriptor)))
+        await expect(rpcRemote.getClosestPeers(toNodeId(clientPeerDescriptor)))
             .rejects.toThrow('Closest peers error')
     })
 

package/test/integration/DhtRpc.test.ts

@@ -1,10 +1,10 @@
 import { createMockDhtRpc, createMockPeerDescriptor, createMockPeers } from '../utils/utils'
 import { ProtoRpcClient, RpcCommunicator, RpcError, toProtoRpcClient } from '@streamr/proto-rpc'
-import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { ClosestPeersRequest, ClosestPeersResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNodeRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
+import { ClosestPeersRequest, ClosestPeersResponse } from '../../generated/packages/dht/protos/DhtRpc'
 import { wait } from '@streamr/utils'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
+import { toNodeId } from '../../src/identifiers'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('DhtRpc', () => {
@@ -18,8 +18,8 @@ describe('DhtRpc', () => {
     const neighbors = createMockPeers()
     const mockDhtRpc = createMockDhtRpc(neighbors)
 
-    const outgoingListener2 = (message: RpcMessage) => {
-        rpcCommunicator1.handleIncomingMessage(message)
+    const outgoingListener2 = async (message: RpcMessage) => {
+        rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
     }
 
     beforeEach(() => {
@@ -29,11 +29,11 @@ describe('DhtRpc', () => {
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator2.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers', mockDhtRpc.getClosestPeers)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message)
+        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
         })
 
-        rpcCommunicator2.on('outgoingMessage', outgoingListener2)
+        rpcCommunicator2.setOutgoingMessageListener(outgoingListener2)
 
         client1 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
         client2 = toProtoRpcClient(new DhtNodeRpcClient(rpcCommunicator1.getRpcClientTransport()))
@@ -53,7 +53,7 @@ describe('DhtRpc', () => {
             }
         )
         const res1 = await response1
-        expect(res1.peers.map((p) => getNodeIdFromPeerDescriptor(p))).toEqual(neighbors.map((n) => getNodeIdFromPeerDescriptor(n)))
+        expect(res1.peers.map((p) => toNodeId(p))).toEqual(neighbors.map((n) => toNodeId(n)))
 
         const response2 = client2.getClosestPeers(
             { nodeId: peerDescriptor2.nodeId, requestId: '1' },
@@ -63,12 +63,11 @@ describe('DhtRpc', () => {
             }
         )
         const res2 = await response2
-        expect(res2.peers.map((p) => getNodeIdFromPeerDescriptor(p))).toEqual(neighbors.map((n) => getNodeIdFromPeerDescriptor(n)))
+        expect(res2.peers.map((p) => toNodeId(p))).toEqual(neighbors.map((n) => toNodeId(n)))
     })
 
     it('Default RPC timeout, client side', async () => {
-        rpcCommunicator2.off('outgoingMessage', outgoingListener2)
-        rpcCommunicator2.on('outgoingMessage', async () => {
+        rpcCommunicator2.setOutgoingMessageListener(async () => {
             await wait(3000)
         })
         const response2 = client2.getClosestPeers(

package/test/integration/Find.test.ts

@@ -1,8 +1,8 @@
 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, waitForStableTopology } from '../utils/utils'
-import { getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
+import { toDhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
 
 const NUM_NODES = 100
 const K = 8
@@ -36,10 +36,10 @@ describe('Find correctness', () => {
     })
 
     it('Entrypoint can find a node from the network (exact match)', async () => {
-        const targetId = getRawFromDhtAddress(nodes[45].getNodeId())
-        const closestNodes = await entryPoint.findClosestNodesFromDht(getDhtAddressFromRaw(targetId))
+        const targetId = toDhtAddressRaw(nodes[45].getNodeId())
+        const closestNodes = await entryPoint.findClosestNodesFromDht(toDhtAddress(targetId))
         expect(closestNodes.length).toBeGreaterThanOrEqual(5)
-        expect(getDhtAddressFromRaw(targetId)).toEqual(getNodeIdFromPeerDescriptor(closestNodes[0]))
+        expect(toDhtAddress(targetId)).toEqual(toNodeId(closestNodes[0]))
     }, 90000)
 
 })