@streamr/dht 101.1.1 → 102.0.0-beta.0

package/test/integration/ConnectionLocking.test.ts

@@ -4,10 +4,10 @@ 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,8 +57,8 @@ 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)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
@@ -68,8 +69,8 @@ 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)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
@@ -84,8 +85,8 @@ 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)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock')
@@ -101,8 +102,8 @@ describe('Connection Locking', () => {
     })
 
     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)),
             connectionManager1.lockConnection(mockPeerDescriptor2, 'testLock1')
@@ -124,8 +125,8 @@ 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)),
@@ -149,8 +150,8 @@ 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)),

package/test/integration/ConnectionManager.test.ts

@@ -1,13 +1,13 @@
-import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
+import { Logger, MetricsContext, waitForCondition, 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 waitForCondition(() => connectionManager2.getConnections().length === 0)
+        expect(connectionManager1.getConnections().length).toEqual(1)
+
+        await connectionManager1.disablePrivateClientMode()
+        await waitForCondition(() => 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()
     })

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 { 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'
 
@@ -59,8 +59,8 @@ describe('DhtNode', () => {
         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))
+        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)
 
 })

package/test/integration/GeoIpConnectivityChecking.test.ts

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

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 = []

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 { Message, NodeType, PeerDescriptor, RouteMessageWrapper } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { Logger, runAndWaitForEvents3, waitForCondition } 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)
         }
 

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