@streamr/dht 0.0.1-tatum.6 → 0.0.1-tatum.8

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -4,7 +4,7 @@ import { Simulator } from '../../src/connection/Simulator/Simulator'
 import { PeerID } from '../../src/helpers/PeerID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { isSamePeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { waitForCondition } from '@streamr/utils'
 
 describe('Storing data in DHT with two peers', () => {
@@ -48,13 +48,13 @@ describe('Storing data in DHT with two peers', () => {
 
         const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
         const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
-        expect(successfulStorers2[0].nodeName).toEqual(otherNode.getPeerDescriptor().nodeName)
+        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
+        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getPeerDescriptor().kademliaId)
 
         const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
         const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(isSamePeerDescriptor(otherNode.getPeerDescriptor(), Any.unpack(foundData1.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData2.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(otherNode.getPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
     })
 
     it('Can store on one peer DHT', async () => {
@@ -63,9 +63,9 @@ describe('Storing data in DHT with two peers', () => {
         const dataKey = PeerID.fromString('data-to-store')
         const data = Any.pack(entryPoint.getPeerDescriptor(), PeerDescriptor)
         const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].nodeName).toEqual(entryPoint.getPeerDescriptor().nodeName)
+        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getPeerDescriptor().kademliaId)
 
         const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(isSamePeerDescriptor(entryPoint.getPeerDescriptor(), Any.unpack(foundData.dataEntries![0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(entryPoint.getPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
     }, 60000)
 })

package/test/integration/{RemoteStore.test.ts → StoreRpcRemote.test.ts}

@@ -5,21 +5,20 @@ import {
     StoreDataRequest,
     StoreDataResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { generateId, MockStoreService } from '../utils/utils'
+import { generateId, mockStoreRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
-import { StoreServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
-import { RemoteStore } from '../../src/dht/store/RemoteStore'
+import { StoreRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { StoreRpcRemote } from '../../src/dht/store/StoreRpcRemote'
 import { Any } from '../../src/proto/google/protobuf/any'
 
-describe('RemoteStore', () => {
+describe('StoreRpcRemote', () => {
 
-    let remoteStore: RemoteStore
+    let rpcRemote: StoreRpcRemote
     let clientRpcCommunicator: RpcCommunicator
     let serverRpcCommunicator: RpcCommunicator
     const serviceId = 'test'
     const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('dhtPeer'),
+        kademliaId: generateId('client'),
         type: NodeType.NODEJS
     }
     const serverPeerDescriptor: PeerDescriptor = {
@@ -36,31 +35,31 @@ describe('RemoteStore', () => {
     beforeEach(() => {
         clientRpcCommunicator = new RpcCommunicator()
         serverRpcCommunicator = new RpcCommunicator()
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', MockStoreService.storeData)
-        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.storeData)
+        clientRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             serverRpcCommunicator.handleIncomingMessage(message)
         })
-        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new StoreServiceClient(clientRpcCommunicator.getRpcClientTransport()))
-        remoteStore = new RemoteStore(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
+        const client = toProtoRpcClient(new StoreRpcClient(clientRpcCommunicator.getRpcClientTransport()))
+        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
     })
 
     it('storeData happy path', async () => {
-        const response = await remoteStore.storeData(request)
+        const response = await rpcRemote.storeData(request)
         expect(response.error).toBeEmpty()
     })
 
     it('storeData rejects', async () => {
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', MockStoreService.throwStoreDataError)
-        await expect(remoteStore.storeData(request))
-            .rejects.toThrowError('Could not store data to 736572766572 from 64687450656572 Error: Mock')
+        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
+        await expect(rpcRemote.storeData(request))
+            .rejects.toThrowError('Could not store data to 736572766572 from 636c69656e74 Error: Mock')
     })
 
     it('storeData response error', async () => {
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', MockStoreService.storeDataErrorString)
-        const response = await remoteStore.storeData(request)
+        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.storeDataErrorString)
+        const response = await rpcRemote.storeData(request)
         expect(response.error).toEqual('Mock')
     })
 

package/test/integration/WebRtcConnectionManagement.test.ts

@@ -6,7 +6,19 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
-import { SimulatorTransport } from '../../src/exports'
+import { SimulatorTransport } from '../../src/connection/Simulator/SimulatorTransport'
+import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
+import { MetricsContext } from '@streamr/utils'
+
+const createConnectionManager = (ownPeerDescriptor: PeerDescriptor, transport: ITransport) => {
+    return new ConnectionManager({
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            transport,
+            createOwnPeerDescriptor: () => ownPeerDescriptor
+        }),
+        metricsContext: new MetricsContext()
+    })
+}
 
 describe('WebRTC Connection Management', () => {
 
@@ -17,32 +29,27 @@ describe('WebRTC Connection Management', () => {
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('peer1').value,
-        nodeName: 'peer1',
         type: NodeType.NODEJS,
     }
 
     const peerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('peer2').value,
-        nodeName: 'peer2',
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
-
         simulator = new Simulator(LatencyType.FIXED, 500)
-
         connectorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
-        manager1 = new ConnectionManager({ transportLayer: connectorTransport1 })
-
+        await connectorTransport1.start()
+        manager1 = createConnectionManager(peerDescriptor1, connectorTransport1)
         connectorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        manager2 = new ConnectionManager({ transportLayer: connectorTransport2 })
-
-        await manager1.start((_msg) => peerDescriptor1)
-        await manager2.start((_msg) => peerDescriptor2)
-
+        await connectorTransport2.start()
+        manager2 = createConnectionManager(peerDescriptor2, connectorTransport2)
+        await manager1.start()
+        await manager2.start()
     })
 
     afterEach(async () => {
@@ -138,26 +145,26 @@ describe('WebRTC Connection Management', () => {
         })
 
         const connectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('connected', () => {
                 //expect(message.messageType).toBe(MessageType.RPC)
                 resolve()
             })
         })
 
         const connectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('connected', (_peerDescriptor: PeerDescriptor) => {
+            manager2.on('connected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 resolve()
             })
         })
 
         const disconnectedPromise2 = new Promise<void>((resolve, _reject) => {
-            manager2.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager2.on('disconnected', () => {
                 resolve()
             })
         })
@@ -186,7 +193,7 @@ describe('WebRTC Connection Management', () => {
         }
 
         const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
-            manager1.on('disconnected', (_peerDescriptor: PeerDescriptor) => {
+            manager1.on('disconnected', () => {
                 resolve()
             })
         })

package/test/integration/WebRtcConnectorRpc.test.ts

@@ -1,5 +1,5 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebRtcConnectorServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebRtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
     NodeType,
@@ -10,29 +10,22 @@ import {
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { generateId } from '../utils/utils'
-import { IWebRtcConnectorService } from '../../src/proto/packages/dht/protos/DhtRpc.server'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { IWebRtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebRTC rpc messages', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client: ProtoRpcClient<WebRtcConnectorServiceClient>
+    let client: ProtoRpcClient<WebRtcConnectorRpcClient>
 
     let requestConnectionCounter: number
     let rtcOfferCounter: number
     let rtcAnswerCounter: number
     let iceCandidateCounter: number
 
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: generateId('peer1'),
-        type: NodeType.NODEJS
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: generateId('peer2'),
+    const targetDescriptor: PeerDescriptor = {
+        kademliaId: generateId('peer'),
         type: NodeType.NODEJS
     }
 
@@ -43,27 +36,27 @@ describe('WebRTC rpc messages', () => {
         iceCandidateCounter = 0
 
         rpcCommunicator1 = new RpcCommunicator()
-        const serverFunctions: IWebRtcConnectorService = {
+        const serverFunctions: IWebRtcConnectorRpc = {
 
-            requestConnection: async (_urequest: WebRtcConnectionRequest, _context: ServerCallContext): Promise<Empty> => {
+            requestConnection: async (): Promise<Empty> => {
                 requestConnectionCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            rtcOffer: async (_urequest: RtcOffer, _context: ServerCallContext): Promise<Empty> => {
+            rtcOffer: async (): Promise<Empty> => {
                 rtcOfferCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            rtcAnswer: async (_urequest: RtcAnswer, _context: ServerCallContext): Promise<Empty> => {
+            rtcAnswer: async (): Promise<Empty> => {
                 rtcAnswerCounter += 1
                 const res: Empty = {}
                 return res
             },
 
-            iceCandidate: async (_urequest: IceCandidate, _context: ServerCallContext): Promise<Empty> => {
+            iceCandidate: async (): Promise<Empty> => {
                 iceCandidateCounter += 1
                 const res: Empty = {}
                 return res
@@ -76,15 +69,15 @@ describe('WebRTC rpc messages', () => {
         rpcCommunicator2.registerRpcNotification(IceCandidate, 'iceCandidate', serverFunctions.iceCandidate)
         rpcCommunicator2.registerRpcNotification(WebRtcConnectionRequest, 'requestConnection', serverFunctions.requestConnection)
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 
-        client = toProtoRpcClient(new WebRtcConnectorServiceClient(rpcCommunicator1.getRpcClientTransport()))
+        client = toProtoRpcClient(new WebRtcConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
     })
 
     afterEach(async () => {
@@ -94,11 +87,9 @@ describe('WebRTC rpc messages', () => {
 
     it('send connectionRequest', async () => {
         client.requestConnection({
-            requester: peerDescriptor1,
-            target: peerDescriptor2,
             connectionId: 'connectionRequest'
         },
-        { targetDescriptor: peerDescriptor2, notification: true }
+        { targetDescriptor, notification: true }
         )
 
         await waitForCondition(() => requestConnectionCounter === 1)
@@ -106,12 +97,10 @@ describe('WebRTC rpc messages', () => {
 
     it('send rtcOffer', async () => {
         client.rtcOffer({
-            requester: peerDescriptor1,
-            target: peerDescriptor2,
             connectionId: 'rtcOffer',
             description: 'aaaaaa'
         },
-        { targetDescriptor: peerDescriptor2, notification: true }
+        { targetDescriptor, notification: true }
         )
 
         await waitForCondition(() => rtcOfferCounter === 1)
@@ -119,12 +108,10 @@ describe('WebRTC rpc messages', () => {
 
     it('send rtcAnswer', async () => {
         client.rtcAnswer({
-            requester: peerDescriptor1,
-            target: peerDescriptor2,
             connectionId: 'rtcOffer',
             description: 'aaaaaa'
         },
-        { targetDescriptor: peerDescriptor2, notification: true }
+        { targetDescriptor, notification: true }
         )
 
         await waitForCondition(() => rtcAnswerCounter === 1)
@@ -132,13 +119,11 @@ describe('WebRTC rpc messages', () => {
 
     it('send iceCandidate', async () => {
         client.iceCandidate({
-            requester: peerDescriptor1,
-            target: peerDescriptor2,
             connectionId: 'rtcOffer',
             candidate: 'aaaaaa',
             mid: 'asdasdasdasdasd'
         },
-        { targetDescriptor: peerDescriptor2, notification: true }
+        { targetDescriptor, notification: true }
         )
 
         await waitForCondition(() => iceCandidateCounter === 1)

package/test/integration/WebSocket.test.ts

@@ -9,11 +9,13 @@ const logger = new Logger(module)
 
 describe('WebSocket', () => {
 
-    const webSocketServer = new WebSocketServer()
+    const webSocketServer = new WebSocketServer({
+        portRange: { min: 9999, max: 9999 }
+    })
     const clientWebSocket = new ClientWebSocket()
 
     beforeAll(async () => {
-        await webSocketServer.start({ min: 9999, max: 9999 })
+        await webSocketServer.start()
     })
 
     it('Happy path', (done) => {

package/test/integration/WebSocketConnectionManagement.test.ts

@@ -1,15 +1,26 @@
 /* eslint-disable promise/no-nesting */
 
+import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
+import { ConnectionType } from '../../src/connection/IConnection'
 import { Simulator } from '../../src/connection/Simulator/Simulator'
-import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { SimulatorTransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
-import { ConnectionType } from '../../src/connection/IConnection'
-import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
-import { waitForCondition } from '@streamr/utils'
+import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
+const createConfig = (ownPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createOwnPeerDescriptor'>) => {
+    return {
+        createConnectorFacade: () => new DefaultConnectorFacade({
+            createOwnPeerDescriptor: () => ownPeerDescriptor,
+            ...opts
+        }),
+        metricsContext: new MetricsContext()
+    }
+}
+
 describe('WebSocket Connection Management', () => {
 
     const serviceId = 'test'
@@ -33,28 +44,30 @@ describe('WebSocket Connection Management', () => {
         type: NodeType.NODEJS,
     }
 
-    let connectorTransport1: ITransport
-    let connectorTransport2: ITransport
+    let connectorTransport1: SimulatorTransport
+    let connectorTransport2: SimulatorTransport
 
     beforeEach(async () => {
 
-        connectorTransport1 = new ConnectionManager({ ownPeerDescriptor: wsServerConnectorPeerDescriptor, simulator: simulator })
-        connectorTransport2 = new ConnectionManager({ ownPeerDescriptor: noWsServerConnectorPeerDescriptor, simulator: simulator })
+        connectorTransport1 = new SimulatorTransport(wsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport1.start()
+        connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport2.start()
 
-        const config1 = {
-            transportLayer: connectorTransport1,
+        const config1 = createConfig(wsServerConnectorPeerDescriptor, {
+            transport: connectorTransport1,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 12223, max: 12223 },
-        }
-        const config2 = {
-            transportLayer: connectorTransport2
-        }
+            websocketPortRange: { min: 12223, max: 12223 }
+        })
+        const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
+            transport: connectorTransport2
+        })
 
         wsServerManager = new ConnectionManager(config1)
         noWsServerManager = new ConnectionManager(config2)
 
-        await wsServerManager.start((_response) => wsServerConnectorPeerDescriptor)
-        await noWsServerManager.start((_response) => noWsServerConnectorPeerDescriptor)
+        await wsServerManager.start()
+        await noWsServerManager.start()
     })
 
     afterEach(async () => {

package/test/integration/WebSocketConnectorRpc.test.ts

@@ -1,5 +1,5 @@
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
-import { WebSocketConnectorServiceClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
+import { WebSocketConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { generateId } from '../utils/utils'
 import {
     NodeType,
@@ -7,15 +7,14 @@ import {
     WebSocketConnectionRequest,
     WebSocketConnectionResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { MockWebSocketConnectorRpc } from '../utils/utils'
-import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { mockWebSocketConnectorRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 
 describe('WebSocketConnectorRpc', () => {
     let rpcCommunicator1: RpcCommunicator
     let rpcCommunicator2: RpcCommunicator
-    let client1: ProtoRpcClient<WebSocketConnectorServiceClient>
-    let client2: ProtoRpcClient<WebSocketConnectorServiceClient>
+    let client1: ProtoRpcClient<WebSocketConnectorRpcClient>
+    let client2: ProtoRpcClient<WebSocketConnectorRpcClient>
 
     const peerDescriptor1: PeerDescriptor = {
         kademliaId: generateId('peer1'),
@@ -33,7 +32,7 @@ describe('WebSocketConnectorRpc', () => {
             WebSocketConnectionRequest,
             WebSocketConnectionResponse,
             'requestConnection',
-            MockWebSocketConnectorRpc.requestConnection
+            mockWebSocketConnectorRpc.requestConnection
         )
 
         rpcCommunicator2 = new RpcCommunicator()
@@ -41,19 +40,19 @@ describe('WebSocketConnectorRpc', () => {
             WebSocketConnectionRequest,
             WebSocketConnectionResponse,
             'requestConnection',
-            MockWebSocketConnectorRpc.requestConnection
+            mockWebSocketConnectorRpc.requestConnection
         )
 
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
 
-        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage, _requestId: string, _ucallContext?: DhtCallContext) => {
+        rpcCommunicator2.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator1.handleIncomingMessage(message)
         })
 
-        client1 = toProtoRpcClient(new WebSocketConnectorServiceClient(rpcCommunicator1.getRpcClientTransport()))
-        client2 = toProtoRpcClient(new WebSocketConnectorServiceClient(rpcCommunicator2.getRpcClientTransport()))
+        client1 = toProtoRpcClient(new WebSocketConnectorRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client2 = toProtoRpcClient(new WebSocketConnectorRpcClient(rpcCommunicator2.getRpcClientTransport()))
     })
 
     afterEach(async () => {
@@ -63,8 +62,6 @@ describe('WebSocketConnectorRpc', () => {
 
     it('Happy path', async () => {
         const response1 = client1.requestConnection({
-            requester: peerDescriptor1,
-            target: peerDescriptor2,
             ip: '127.0.0.1',
             port: 9099
         },
@@ -74,8 +71,6 @@ describe('WebSocketConnectorRpc', () => {
         expect(res1.accepted).toEqual(true)
 
         const response2 = client2.requestConnection({
-            requester: peerDescriptor2,
-            target: peerDescriptor1,
             ip: '127.0.0.1',
             port: 9111
         },

package/test/unit/DuplicateDetector.test.ts

@@ -3,25 +3,24 @@ import { DuplicateDetector } from '../../src/dht/routing/DuplicateDetector'
 describe('Duplicate Detector', () => {
     let detector: DuplicateDetector
     const maxLimit = 10
-    const senderId = 'sender'
     beforeEach(async () => {
         detector = new DuplicateDetector(maxLimit, 100)
     })
 
     it('detects duplicates', async () => {
-        detector.add('test', senderId)
+        detector.add('test')
         expect(detector.size()).toEqual(1)
         expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
     })
 
     it('resets on resetLimit', () => {
         for (let i = 0; i < maxLimit; i++) {
-            detector.add(`test${i}`, senderId)
+            detector.add(`test${i}`)
         }
         for (let i = 0; i < maxLimit; i++) {
             expect(detector.isMostLikelyDuplicate(`test${i}`)).toEqual(true)
         }
-        detector.add('test10', senderId)
+        detector.add('test10')
         expect(detector.size()).toEqual(10)
         expect(detector.isMostLikelyDuplicate('test0')).toEqual(false)
         expect(detector.isMostLikelyDuplicate('test10')).toEqual(true)

package/test/unit/LocalDataStore.test.ts

@@ -1,7 +1,7 @@
 import { Any } from '../../src/proto/google/protobuf/any'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import {
-    isSamePeerDescriptor,
+    areEqualPeerDescriptors,
     keyFromPeerDescriptor,
     peerIdFromPeerDescriptor
 } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -13,13 +13,11 @@ describe('LocalDataStore', () => {
     let localDataStore: LocalDataStore
     const storer1: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        type: NodeType.NODEJS,
-        nodeName: 'storer1'
+        type: NodeType.NODEJS
     }
     const storer2: PeerDescriptor = {
         kademliaId: new Uint8Array([3, 2, 1]),
-        type: NodeType.NODEJS,
-        nodeName: 'storer2'
+        type: NodeType.NODEJS
     }
     const data1 = Any.pack(storer1, PeerDescriptor)
     const data2 = Any.pack(storer2, PeerDescriptor)
@@ -39,7 +37,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
         })
     })
 
@@ -52,7 +50,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
         })
     })
 
@@ -66,7 +64,7 @@ describe('LocalDataStore', () => {
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(isSamePeerDescriptor(fetchedDescriptor, storer2)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storer2)).toBeTrue()
         })
     })
 

package/test/unit/RandomContactList.test.ts

@@ -1,5 +1,5 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import { PeerID } from '../../src/exports'
+import { PeerID } from '../../src/helpers/PeerID'
 
 const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
     return { getPeerId: () => PeerID.fromValue(kademliaId) }