@streamr/dht 101.1.1 → 102.0.0-beta.0

package/test/integration/SimultaneousConnections.test.ts

@@ -3,12 +3,12 @@ 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 waitForCondition(() => simTransport2.hasConnection(toNodeId(peerDescriptor1)))
+        await waitForCondition(() => 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 waitForCondition(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
+            await waitForCondition(() => 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 waitForCondition(() => connectionManager1.hasConnection(toNodeId(wsPeerDescriptor2)))
+            await waitForCondition(() => 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 waitForCondition(() => connectionManager1.hasConnection(toNodeId(wrtcPeerDescriptor2)))
+            await waitForCondition(() => 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', () => {
 
@@ -41,15 +41,15 @@ describe('Storing data in DHT with two peers', () => {
         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

@@ -3,7 +3,7 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { waitForCondition } from '@streamr/utils'
 import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { toDhtAddress } from '../../src/identifiers'
 
 describe('Storing data in DHT with two peers', () => {
 
@@ -32,10 +32,10 @@ describe('Storing data in DHT with two peers', () => {
     it('Node can store on two peer DHT', async () => {
         const storedData1 = createMockDataEntry()
         const storedData2 = createMockDataEntry()
-        await otherNode.storeDataToDht(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)
     })
@@ -44,8 +44,8 @@ describe('Storing data in DHT with two peers', () => {
         await otherNode.stop()
         await waitForCondition(() => 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)
     })
@@ -47,7 +47,7 @@ describe('StoreRpcRemote', () => {
         serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
         await expect(rpcRemote.storeData(request)).rejects.toThrowError(
             'Could not store data to'
-            + ` ${getNodeIdFromPeerDescriptor(serverPeerDescriptor)} from ${getNodeIdFromPeerDescriptor(clientPeerDescriptor)}`
+            + ` ${toNodeId(serverPeerDescriptor)} from ${toNodeId(clientPeerDescriptor)}`
             + ' Error: Mock'
         )
     })

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -1,7 +1,7 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { Message, NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
@@ -15,7 +15,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
             transport,
             createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     })
 }
 

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -1,16 +1,16 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebrtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebrtcConnectorRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
-} from '../../src/proto/packages/dht/protos/DhtRpc'
-import { Empty } from '../../src/proto/google/protobuf/empty'
+} from '../../generated/packages/dht/protos/DhtRpc'
+import { Empty } from '../../generated/google/protobuf/empty'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { IWebrtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
+import { IWebrtcConnectorRpc } from '../../generated/packages/dht/protos/DhtRpc.server'
 import { waitForCondition } from '@streamr/utils'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebRTC rpc messages', () => {
@@ -64,12 +64,12 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
         rpcCommunicator2.registerRpcNotification(WebrtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message)
+        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator1.handleIncomingMessage(message)
+        rpcCommunicator2.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
         })
 
         client = toProtoRpcClient(new WebrtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))

package/test/integration/Websocket.test.ts

@@ -1,5 +1,3 @@
-/* eslint-disable no-console */
-
 import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
 import { IConnection } from '../../src/connection/IConnection'
 import { WebsocketClientConnection } from '../../src/connection/websocket/NodeWebsocketClientConnection'

package/test/integration/WebsocketClientConnectorRpc.test.ts

@@ -1,9 +1,9 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebsocketClientConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebsocketClientConnectorRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
 import { createMockPeerDescriptor, mockWebsocketClientConnectorRpc } from '../utils/utils'
-import { WebsocketConnectionRequest } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Empty } from '../../src/proto/google/protobuf/empty'
+import { WebsocketConnectionRequest } from '../../generated/packages/dht/protos/DhtRpc'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
+import { Empty } from '../../generated/google/protobuf/empty'
 import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebsocketClientConnectorRpc', () => {
@@ -32,12 +32,12 @@ describe('WebsocketClientConnectorRpc', () => {
             mockWebsocketClientConnectorRpc.requestConnection
         )
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message)
+        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator1.handleIncomingMessage(message)
+        rpcCommunicator2.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator1.handleIncomingMessage(message, new DhtCallContext())
         })
 
         client1 = toProtoRpcClient(new WebsocketClientConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -1,15 +1,13 @@
-/* eslint-disable promise/no-nesting */
-
 import { MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
 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 * as Err from '../../src/helpers/errors'
-import { Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { 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 { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { toNodeId } from '../../src/identifiers'
 
 const SERVICE_ID = 'test'
 
@@ -19,7 +17,8 @@ const createOptions = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultCo
             createLocalPeerDescriptor: async () => localPeerDescriptor,
             ...opts
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     }
 }
 
@@ -145,7 +144,7 @@ describe('Websocket Connection Management', () => {
             waitForEvent3<TransportEvents>(wsServerManager, 'disconnected', 15000),
             wsServerManager.send(dummyMessage)
         ])
-        expect(wsServerManager.hasConnection(getNodeIdFromPeerDescriptor(dummyMessage.targetDescriptor!))).toBeFalse()
+        expect(wsServerManager.hasConnection(toNodeId(dummyMessage.targetDescriptor!))).toBeFalse()
     }, 20000)
     
     it('Can open connections to peer with server', async () => {
@@ -161,12 +160,12 @@ describe('Websocket Connection Management', () => {
         await noWsServerManager.send(dummyMessage)
         await waitForCondition(
             () => {
-                const nodeId = getNodeIdFromPeerDescriptor(noWsServerConnectorPeerDescriptor)
+                const nodeId = toNodeId(noWsServerConnectorPeerDescriptor)
                 return wsServerManager.hasConnection(nodeId)
             }
         )
         await waitForCondition(
-            () => noWsServerManager.hasConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))
+            () => noWsServerManager.hasConnection(toNodeId(wsServerConnectorPeerDescriptor))
         )
     })
 

package/test/integration/{rpc-connections-over-webrpc.test.ts → rpc-connections-over-webrtc.test.ts}

@@ -6,8 +6,8 @@ import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTran
 import { DhtRpcOptions } from '../../src/rpc-protocol/DhtRpcOptions'
 import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
 import { ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
-import { DhtNodeRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { PeerDescriptor, PingRequest, PingResponse } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtNodeRpcClient } from '../../generated/packages/dht/protos/DhtRpc.client'
+import { PeerDescriptor, PingRequest, PingResponse } from '../../generated/packages/dht/protos/DhtRpc'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -20,7 +20,8 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
             transport,
             createLocalPeerDescriptor: async () => localPeerDescriptor
         }),
-        metricsContext: new MetricsContext()
+        metricsContext: new MetricsContext(),
+        allowIncomingPrivateConnections: false
     })
 }
 

package/test/unit/ConnectionManager.test.ts

@@ -1,6 +1,6 @@
 import { MetricsContext } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
-import { getNodeIdFromPeerDescriptor, PendingConnection } from '../../src/exports'
+import { toNodeId, PendingConnection } from '../../src/exports'
 import { FakeConnectorFacade } from '../utils/FakeConnectorFacade'
 import { MockConnection } from '../utils/mock/MockConnection'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -15,6 +15,7 @@ describe('ConnetionManager', () => {
     beforeEach(async () => {
         connectionManager = new ConnectionManager({
             metricsContext: new MetricsContext(),
+            allowIncomingPrivateConnections: false,
             createConnectorFacade: () => { 
                 fakeConnectorFacade = new FakeConnectorFacade(localPeerDescriptor)
                 return fakeConnectorFacade
@@ -30,7 +31,7 @@ describe('ConnetionManager', () => {
     it('should replace a duplicate connecting connection', () => {
         const remotePeerDescriptor = createMockPeerDescriptor()
         const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
-        const offerer = getOfferer(getNodeIdFromPeerDescriptor(localPeerDescriptor), getNodeIdFromPeerDescriptor(remotePeerDescriptor))
+        const offerer = getOfferer(toNodeId(localPeerDescriptor), toNodeId(remotePeerDescriptor))
         const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
         expect(accepted1).toBeTrue()
         const pendingConnection2 = new PendingConnection(remotePeerDescriptor)
@@ -45,7 +46,7 @@ describe('ConnetionManager', () => {
     it('should replace a duplicate connected connection', () => {
         const remotePeerDescriptor = createMockPeerDescriptor()
         const pendingConnection1 = new PendingConnection(remotePeerDescriptor)
-        const offerer = getOfferer(getNodeIdFromPeerDescriptor(localPeerDescriptor), getNodeIdFromPeerDescriptor(remotePeerDescriptor))
+        const offerer = getOfferer(toNodeId(localPeerDescriptor), toNodeId(remotePeerDescriptor))
         const accepted1 = fakeConnectorFacade.callOnNewConnection(pendingConnection1)
         expect(accepted1).toBeTrue()
         pendingConnection1.onHandshakeCompleted(new MockConnection())

package/test/unit/ConnectivityHelpers.test.ts

@@ -1,4 +1,4 @@
-import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { NodeType } from '../../generated/packages/dht/protos/DhtRpc'
 import { expectedConnectionType } from '../../src/helpers/Connectivity'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { createMockPeerDescriptor } from '../utils/utils'

package/test/unit/DiscoverySession.test.ts

@@ -3,8 +3,8 @@ import { sampleSize } from 'lodash'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { PeerManager, getDistance } from '../../src/dht/PeerManager'
 import { DiscoverySession } from '../../src/dht/discovery/DiscoverySession'
-import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { DhtAddress, toNodeId, toDhtAddressRaw } from '../../src/identifiers'
+import { NodeType, PeerDescriptor } from '../../generated/packages/dht/protos/DhtRpc'
 import { createTestTopology } from '../utils/topology'
 import { getClosestNodes } from '../../src/dht/contact/getClosestNodes'
 
@@ -16,7 +16,7 @@ const QUERY_BATCH_SIZE = 5  // the default value in DhtNode's options, not relev
 
 const createPeerDescriptor = (nodeId: DhtAddress): PeerDescriptor => {
     return {
-        nodeId: getRawFromDhtAddress(nodeId),
+        nodeId: toDhtAddressRaw(nodeId),
         type: NodeType.NODEJS
     }
 }
@@ -45,9 +45,9 @@ describe('DiscoverySession', () => {
     }
 
     const createMockRpcRemote = (peerDescriptor: PeerDescriptor): Partial<DhtNodeRpcRemote> => {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         return {
-            id: getRawFromDhtAddress(nodeId),
+            id: toDhtAddressRaw(nodeId),
             getPeerDescriptor: () => peerDescriptor,
             getNodeId: () => nodeId,
             getClosestPeers: async (referenceId: DhtAddress) => {
@@ -79,7 +79,7 @@ describe('DiscoverySession', () => {
         // Each queried node should closer to the target than the previous queried node, because we
         // use parallelism=1 and noProgressLimit=1
         const distancesToTarget = queriedNodes
-            .map((nodeId) => getDistance(getRawFromDhtAddress(nodeId), getRawFromDhtAddress(targetId)))
+            .map((nodeId) => getDistance(toDhtAddressRaw(nodeId), toDhtAddressRaw(targetId)))
         for (let i = 1; i < distancesToTarget.length ; i++) {
             expect(distancesToTarget[i]).toBeLessThan(distancesToTarget[i - 1])
         }

package/test/unit/Handshaker.test.ts

@@ -10,7 +10,7 @@ import {
 } from '../../src/connection/Handshaker'
 import { ConnectionEvents, IConnection } from '../../src/connection/IConnection'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { HandshakeError, Message } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { HandshakeError, Message } from '../../generated/packages/dht/protos/DhtRpc'
 import { PendingConnection } from '../../src/connection/PendingConnection'
 
 describe('Handshaker', () => {

package/test/unit/ListeningRpcCommunicator.test.ts

@@ -0,0 +1,52 @@
+import { waitForCondition } from '@streamr/utils'
+import { ListeningRpcCommunicator } from '../../src/transport/ListeningRpcCommunicator'
+import { MockTransport } from '../utils/mock/MockTransport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { RpcMessage } from '@streamr/proto-rpc'
+import { Deferred, RpcMetadata, RpcStatus } from '@protobuf-ts/runtime-rpc'
+
+const createDeferredPromises = () => {
+
+    const defHeader = new Deferred<RpcMetadata>()
+    const defMessage = new Deferred<any>()
+    const defStatus = new Deferred<RpcStatus>()
+    const defTrailer = new Deferred<RpcMetadata>()
+    
+    const deferredParser = () => {}
+    return {
+        message: defMessage,
+        header: defHeader,
+        trailer: defTrailer,
+        status: defStatus,
+        messageParser: deferredParser as any
+    }
+}
+
+describe('ListeningRpcCommunicator', () => {
+    const SERVICE_ID = 'test'
+    let rpcCommunicator: ListeningRpcCommunicator
+    let transport: MockTransport
+
+    beforeEach(() => {
+        transport = new MockTransport()
+        rpcCommunicator = new ListeningRpcCommunicator(SERVICE_ID, transport)
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+        transport.stop()
+    })
+
+    it('rejects requests on disconnect event to the target', async () => {
+        const peerDescriptor = createMockPeerDescriptor()
+        rpcCommunicator.getRpcClientTransport().emit(
+            'rpcRequest',
+            RpcMessage.create(),
+            { targetDescriptor: peerDescriptor }, createDeferredPromises()
+        )
+        await waitForCondition(() => rpcCommunicator.getRequestIds(() => true).length > 0)
+        transport.emit('disconnected', peerDescriptor, false)
+        await waitForCondition(() => rpcCommunicator.getRequestIds(() => true).length === 0)
+    }, 10000)
+
+})