@streamr/trackerless-network 0.0.1-tatum.5 → 0.0.1-tatum.7

package/test/end-to-end/proxy-key-exchange.test.ts

@@ -12,9 +12,10 @@ import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
+
 describe('proxy group key exchange', () => {
     const proxyNodeDescriptor = createMockPeerDescriptor({
-        nodeName: 'proxyNode',
         websocket: { host: '127.0.0.1', port: 23134, tls: false }
     })
     const publisherDescriptor = createMockPeerDescriptor()
@@ -23,8 +24,6 @@ describe('proxy group key exchange', () => {
     const publisherUserId = toEthereumAddress('0x823A026e226EB47980c88616e01E1D3305Ef8Ecb')
     const subscriberUserId = toEthereumAddress('0x73E6183bf9b79D30533bEC7B28e982e9Af649B23')
 
-    const streamPartId = StreamPartIDUtils.parse('proxy-test#0')
-
     let proxyNode: NetworkNode
     let publisher: NetworkNode
     let subscriber: NetworkNode
@@ -40,8 +39,8 @@ describe('proxy group key exchange', () => {
             }
         })
         await proxyNode.start()
-        proxyNode.setStreamPartEntryPoints(streamPartId, [proxyNodeDescriptor])
-        proxyNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
+        proxyNode.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor])
+        proxyNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
         publisher = createNetworkNode({
             layer0: {
                 entryPoints: [publisherDescriptor],
@@ -66,8 +65,8 @@ describe('proxy group key exchange', () => {
     })
     
     it('happy path request', async () => {
-        await publisher.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
-        await subscriber.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
+        await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
+        await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
         const requestContent = utf8ToBinary(new GroupKeyRequest({
             recipient: publisherUserId,
@@ -79,8 +78,8 @@ describe('proxy group key exchange', () => {
         }).serialize())
         const request = new StreamMessage({
             messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(streamPartId),
-                StreamPartIDUtils.getStreamPartition(streamPartId),
+                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 Date.now(),
                 0,
                 subscriberUserId,
@@ -99,8 +98,8 @@ describe('proxy group key exchange', () => {
     })
 
     it('happy path response', async () => {
-        await publisher.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
-        await subscriber.setProxies(streamPartId, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
+        await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
+        await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
         const responseContent = utf8ToBinary(new GroupKeyResponse({
             recipient: publisherUserId,
@@ -109,8 +108,8 @@ describe('proxy group key exchange', () => {
         }).serialize())
         const response = new StreamMessage({
             messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(streamPartId),
-                StreamPartIDUtils.getStreamPartition(streamPartId),
+                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 Date.now(),
                 0,
                 publisherUserId,

package/test/end-to-end/random-graph-with-real-connections.test.ts

@@ -14,7 +14,7 @@ describe('random graph with real connections', () => {
         websocket: { host: '127.0.0.1', port: 12221, tls: false }
     }
 
-    const randomGraphId = StreamPartIDUtils.parse('random-graph#0')
+    const streamPartId = StreamPartIDUtils.parse('random-graph#0')
     let epDhtNode: DhtNode
     let dhtNode1: DhtNode
     let dhtNode2: DhtNode
@@ -41,7 +41,7 @@ describe('random graph with real connections', () => {
 
         randomGraphNode1 = createRandomGraphNode(
             {
-                randomGraphId,
+                streamPartId,
                 layer1: epDhtNode,
                 P2PTransport: epDhtNode.getTransport(),
                 connectionLocker: epDhtNode.getTransport() as ConnectionManager,
@@ -49,28 +49,28 @@ describe('random graph with real connections', () => {
             }
         )
         randomGraphNode2 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode1,
             P2PTransport: dhtNode1.getTransport(),
             connectionLocker: dhtNode1.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode1.getPeerDescriptor()
         })
         randomGraphNode3 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode2,
             P2PTransport: dhtNode2.getTransport(),
             connectionLocker: dhtNode2.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode2.getPeerDescriptor()
         })
         randomGraphNode4 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode3,
             P2PTransport: dhtNode3.getTransport(),
             connectionLocker: dhtNode3.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode3.getPeerDescriptor()
         })
         randomGraphNode5 = createRandomGraphNode({
-            randomGraphId,
+            streamPartId,
             layer1: dhtNode4,
             P2PTransport: dhtNode4.getTransport(),
             connectionLocker: dhtNode4.getTransport() as ConnectionManager,
@@ -144,7 +144,7 @@ describe('random graph with real connections', () => {
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         randomGraphNode1.broadcast(msg)

package/test/end-to-end/webrtc-full-node-network.test.ts

@@ -16,7 +16,7 @@ describe('Full node network with WebRTC connections', () => {
         region: getRandomRegion()
     })
 
-    const randomGraphId = StreamPartIDUtils.parse('webrtc-network#0')
+    const streamPartId = StreamPartIDUtils.parse('webrtc-network#0')
 
     let entryPoint: NetworkStack
 
@@ -33,8 +33,8 @@ describe('Full node network with WebRTC connections', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-        entryPoint.getStreamrNode()!.joinStreamPart(randomGraphId)
+        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getStreamrNode()!.joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async () => {
             const peerDescriptor = createMockPeerDescriptor()
@@ -46,8 +46,8 @@ describe('Full node network with WebRTC connections', () => {
             })
             nodes.push(node)
             await node.start()
-            node.getStreamrNode().setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-            node.getStreamrNode().joinStreamPart(randomGraphId)
+            node.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+            node.getStreamrNode().joinStreamPart(streamPartId)
         }))
 
     }, 90000)
@@ -62,13 +62,13 @@ describe('Full node network with WebRTC connections', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(randomGraphId).length >= 3
+                return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 3
             }
             , 120000)
         ))
         let numOfMessagesReceived = 0
         const successIds: string[] = []
-        nodes.map((node) => {
+        nodes.forEach((node) => {
             node.getStreamrNode()!.on('newMessage', () => {
                 successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
                 numOfMessagesReceived += 1
@@ -76,7 +76,7 @@ describe('Full node network with WebRTC connections', () => {
         })
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         entryPoint.getStreamrNode()!.broadcast(msg)

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -10,10 +10,9 @@ describe('Full node network with WebSocket connections only', () => {
 
     const NUM_OF_NODES = 48
     const epPeerDescriptor = createMockPeerDescriptor({
-        nodeName: 'entrypoint',
         websocket: { host: '127.0.0.1', port: 15555, tls: false }
     })
-    const randomGraphId = StreamPartIDUtils.parse('websocket-network#0')
+    const streamPartId = StreamPartIDUtils.parse('websocket-network#0')
 
     let entryPoint: NetworkStack
 
@@ -30,22 +29,21 @@ describe('Full node network with WebSocket connections only', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-        entryPoint.getStreamrNode()!.joinStreamPart(randomGraphId)
+        entryPoint.getStreamrNode()!.setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getStreamrNode()!.joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async (i) => {
             const node = new NetworkStack({
                 layer0: {
                     entryPoints: [epPeerDescriptor],
                     websocketPortRange: { min: 15556 + i, max: 15556 + i },
-                    nodeName: `${i}`,
                     numberOfNodesPerKBucket: 4
                 }
             })
             nodes.push(node)
             await node.start()
-            node.getStreamrNode().setStreamPartEntryPoints(randomGraphId, [epPeerDescriptor])
-            node.getStreamrNode().joinStreamPart(randomGraphId)
+            node.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+            node.getStreamrNode().joinStreamPart(streamPartId)
         }))
 
     }, 120000)
@@ -60,13 +58,13 @@ describe('Full node network with WebSocket connections only', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode()!.getNeighbors(randomGraphId).length >= 3
+                return node.getStreamrNode()!.getNeighbors(streamPartId).length >= 4
             }
             , 120000)
         ))
         let numOfMessagesReceived = 0
         const successIds: string[] = []
-        nodes.map((node) => {
+        nodes.forEach((node) => {
             node.getStreamrNode()!.on('newMessage', () => {
                 successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
                 numOfMessagesReceived += 1
@@ -75,7 +73,7 @@ describe('Full node network with WebSocket connections only', () => {
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         entryPoint.getStreamrNode()!.broadcast(msg)

package/test/integration/{RemoteRandomGraphNode.test.ts → DeliveryRpcRemote.test.ts}

@@ -5,24 +5,25 @@ import {
     SimulatorTransport,
     NodeType
 } from '@streamr/dht'
-import { RemoteRandomGraphNode } from '../../src/logic/RemoteRandomGraphNode'
-import { NetworkRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { waitForCondition } from '@streamr/utils'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-describe('RemoteRandomGraphNode', () => {
+const STREAM_PART_ID = StreamPartIDUtils.parse('test-stream#0')
+
+describe('DeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let remoteRandomGraphNode: RemoteRandomGraphNode
+    let rpcRemote: DeliveryRpcRemote
 
     const clientNode: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
@@ -39,11 +40,13 @@ describe('RemoteRandomGraphNode', () => {
     let mockConnectionManager1: SimulatorTransport
     let mockConnectionManager2: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         recvCounter = 0
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
+        await mockConnectionManager1.start()
         mockConnectionManager2 = new SimulatorTransport(clientNode, simulator)
+        await mockConnectionManager2.start()
         
         mockServerRpc = new ListeningRpcCommunicator('test', mockConnectionManager1)
         clientRpc = new ListeningRpcCommunicator('test', mockConnectionManager2)
@@ -51,7 +54,7 @@ describe('RemoteRandomGraphNode', () => {
         mockServerRpc.registerRpcNotification(
             StreamMessage,
             'sendStreamMessage',
-            async (_msg: StreamMessage, _context: ServerCallContext): Promise<Empty> => {
+            async (): Promise<Empty> => {
                 recvCounter += 1
                 return Empty
             }
@@ -60,17 +63,17 @@ describe('RemoteRandomGraphNode', () => {
         mockServerRpc.registerRpcNotification(
             LeaveStreamPartNotice,
             'leaveStreamPartNotice',
-            async (_msg: LeaveStreamPartNotice, _context: ServerCallContext): Promise<Empty> => {
+            async (): Promise<Empty> => {
                 recvCounter += 1
                 return Empty
             }
         )
 
-        remoteRandomGraphNode = new RemoteRandomGraphNode(
+        rpcRemote = new DeliveryRpcRemote(
             clientNode,
             serverNode,
-            'test-stream',
-            toProtoRpcClient(new NetworkRpcClient(clientRpc.getRpcClientTransport()))
+            STREAM_PART_ID,
+            toProtoRpcClient(new DeliveryRpcClient(clientRpc.getRpcClientTransport()))
         )
     })
 
@@ -85,16 +88,16 @@ describe('RemoteRandomGraphNode', () => {
     it('sendStreamMessage', async () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            StreamPartIDUtils.parse('test-stream#0'),
+            STREAM_PART_ID,
             randomEthereumAddress()
         )
 
-        await remoteRandomGraphNode.sendStreamMessage(msg)
+        await rpcRemote.sendStreamMessage(msg)
         await waitForCondition(() => recvCounter === 1)
     })
 
     it('leaveNotice', async () => {
-        remoteRandomGraphNode.leaveStreamPartNotice()
+        rpcRemote.leaveStreamPartNotice()
         await waitForCondition(() => recvCounter === 1)
     })
 

package/test/integration/{RemoteHandshaker.test.ts → HandshakeRpcRemote.test.ts}

@@ -2,7 +2,6 @@ import {
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     ListeningRpcCommunicator,
     NodeType,
@@ -14,12 +13,12 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { RemoteHandshaker } from '../../src/logic/neighbor-discovery/RemoteHandshaker'
+import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
 
-describe('RemoteHandshaker', () => {
+describe('HandshakeRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let remoteHandshaker: RemoteHandshaker
+    let rpcRemote: HandshakeRpcRemote
 
     const clientNode: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
@@ -34,11 +33,13 @@ describe('RemoteHandshaker', () => {
     let mockConnectionManager1: SimulatorTransport
     let mockConnectionManager2: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         Simulator.useFakeTimers()
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
+        await mockConnectionManager1.start()
         mockConnectionManager2 = new SimulatorTransport(clientNode, simulator)
+        await mockConnectionManager2.start()
 
         mockServerRpc = new ListeningRpcCommunicator('test', mockConnectionManager1)
         clientRpc = new ListeningRpcCommunicator('test', mockConnectionManager2)
@@ -47,7 +48,7 @@ describe('RemoteHandshaker', () => {
             StreamPartHandshakeRequest,
             StreamPartHandshakeResponse,
             'handshake',
-            async (msg: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+            async (msg: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
                 const res: StreamPartHandshakeResponse = {
                     requestId: msg.requestId,
                     accepted: true
@@ -56,10 +57,10 @@ describe('RemoteHandshaker', () => {
             }
         )
 
-        remoteHandshaker = new RemoteHandshaker(
+        rpcRemote = new HandshakeRpcRemote(
             clientNode,
             serverNode,
-            'test-stream',
+            'test-stream-part',
             toProtoRpcClient(new HandshakeRpcClient(clientRpc.getRpcClientTransport()))
         )
     })
@@ -74,7 +75,7 @@ describe('RemoteHandshaker', () => {
     })
 
     it('handshake', async () => {
-        const result = await remoteHandshaker.handshake([])
+        const result = await rpcRemote.handshake([])
         expect(result.accepted).toEqual(true)
     })
 })

package/test/integration/Handshakes.test.ts

@@ -13,9 +13,9 @@ import {
 import { NodeList } from '../../src/logic/NodeList'
 import { mockConnectionLocker } from '../utils/utils'
 import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { RemoteHandshaker } from '../../src/logic/neighbor-discovery/RemoteHandshaker'
+import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshakes', () => {
 
@@ -37,9 +37,9 @@ describe('Handshakes', () => {
     let nodeView: NodeList
     let targetNeighbors: NodeList
     let handshaker: Handshaker
-    const randomGraphId = 'handshaker'
+    const streamPartId = StreamPartIDUtils.parse('stream#0')
 
-    const acceptHandshake = async (request: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+    const acceptHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
         const response: StreamPartHandshakeResponse = {
             requestId: request.requestId,
             accepted: true
@@ -47,7 +47,7 @@ describe('Handshakes', () => {
         return response
     }
 
-    const rejectHandshake = async (request: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+    const rejectHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
         const response: StreamPartHandshakeResponse = {
             requestId: request.requestId,
             accepted: false
@@ -55,7 +55,7 @@ describe('Handshakes', () => {
         return response
     }
 
-    const interleavingHandshake = async (request: StreamPartHandshakeRequest, _context: ServerCallContext): Promise<StreamPartHandshakeResponse> => {
+    const interleavingHandshake = async (request: StreamPartHandshakeRequest): Promise<StreamPartHandshakeResponse> => {
         const response: StreamPartHandshakeResponse = {
             requestId: request.requestId,
             accepted: true,
@@ -69,29 +69,32 @@ describe('Handshakes', () => {
     let simulatorTransport2: SimulatorTransport
     let simulatorTransport3: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         Simulator.useFakeTimers()
         simulator = new Simulator()
         simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await simulatorTransport1.start()
         simulatorTransport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await simulatorTransport2.start()
         simulatorTransport3 = new SimulatorTransport(peerDescriptor3, simulator)
+        await simulatorTransport3.start()
 
-        rpcCommunicator1 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport1)
-        rpcCommunicator2 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport2)
-        rpcCommunicator3 = new ListeningRpcCommunicator(randomGraphId, simulatorTransport3)
+        rpcCommunicator1 = new ListeningRpcCommunicator(streamPartId, simulatorTransport1)
+        rpcCommunicator2 = new ListeningRpcCommunicator(streamPartId, simulatorTransport2)
+        rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
 
         const handshakerNodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
         nodeView = new NodeList(handshakerNodeId, 10)
         targetNeighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
             ownPeerDescriptor: peerDescriptor2,
-            randomGraphId,
+            streamPartId,
             nearbyNodeView: nodeView,
             randomNodeView: nodeView,
             targetNeighbors,
             connectionLocker: mockConnectionLocker,
             rpcCommunicator: rpcCommunicator2,
-            N: 4
+            maxNeighborCount: 4
         })
 
     })
@@ -111,10 +114,10 @@ describe('Handshakes', () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )
@@ -126,10 +129,10 @@ describe('Handshakes', () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )
@@ -141,10 +144,10 @@ describe('Handshakes', () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', rejectHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )
@@ -157,10 +160,10 @@ describe('Handshakes', () => {
         rpcCommunicator3.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
         // @ts-expect-error private
         const res = await handshaker.handshakeWithTarget(
-            new RemoteHandshaker(
+            new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                randomGraphId,
+                streamPartId,
                 toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
             )
         )

package/test/integration/Inspect.test.ts

@@ -24,12 +24,13 @@ describe('inspect', () => {
     let publishInterval: NodeJS.Timeout
 
     const initiateNode = async (peerDescriptor: PeerDescriptor, simulator: Simulator): Promise<NetworkStack> => {
-        const transportLayer = new SimulatorTransport(peerDescriptor, simulator)
+        const transport = new SimulatorTransport(peerDescriptor, simulator)
+        await transport.start()
         const node = new NetworkStack({
             layer0: {
                 entryPoints: [publisherDescriptor],
                 peerDescriptor,
-                transportLayer
+                transport
             }
         })
         await node.start()

package/test/integration/{RemoteNeighborUpdateManager.test.ts → NeighborUpdateRpcRemote.test.ts}

@@ -1,4 +1,3 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import {
     ListeningRpcCommunicator,
     NodeType,
@@ -7,16 +6,17 @@ import {
     SimulatorTransport
 } from '@streamr/dht'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { RemoteNeighborUpdateManager } from '../../src/logic/neighbor-discovery/RemoteNeighborUpdateManager'
+import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
 import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
     NeighborUpdateRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
-describe('RemoteNeighborUpdateManager', () => {
+describe('NeighborUpdateRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let neighborUpdateRpcClient: RemoteNeighborUpdateManager
+    let rpcRemote: NeighborUpdateRpcRemote
 
     const clientNode: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
@@ -31,10 +31,12 @@ describe('RemoteNeighborUpdateManager', () => {
     let mockConnectionManager1: SimulatorTransport
     let mockConnectionManager2: SimulatorTransport
 
-    beforeEach(() => {
+    beforeEach(async () => {
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
+        await mockConnectionManager1.start()
         mockConnectionManager2 = new SimulatorTransport(clientNode, simulator)
+        await mockConnectionManager2.start()
 
         mockServerRpc = new ListeningRpcCommunicator('test', mockConnectionManager1)
         clientRpc = new ListeningRpcCommunicator('test', mockConnectionManager2)
@@ -43,13 +45,13 @@ describe('RemoteNeighborUpdateManager', () => {
             NeighborUpdate,
             NeighborUpdate,
             'neighborUpdate',
-            async (_msg: NeighborUpdate, _context: ServerCallContext): Promise<NeighborUpdate> => {
+            async (): Promise<NeighborUpdate> => {
                 const node: PeerDescriptor = {
                     kademliaId: new Uint8Array([4, 2, 4]),
                     type: NodeType.NODEJS
                 }
                 const update: NeighborUpdate = {
-                    randomGraphId: 'testStream',
+                    streamPartId: StreamPartIDUtils.parse('stream#0'),
                     neighborDescriptors: [
                         node
                     ],
@@ -58,10 +60,10 @@ describe('RemoteNeighborUpdateManager', () => {
                 return update
             }
         )
-        neighborUpdateRpcClient = new RemoteNeighborUpdateManager(
+        rpcRemote = new NeighborUpdateRpcRemote(
             clientNode,
             serverNode,
-            'test-stream',
+            'test-stream-part',
             toProtoRpcClient(new NeighborUpdateRpcClient(clientRpc.getRpcClientTransport()))
         )
     })
@@ -75,7 +77,7 @@ describe('RemoteNeighborUpdateManager', () => {
     })
 
     it('updateNeighbors', async () => {
-        const res = await neighborUpdateRpcClient.updateNeighbors([])
+        const res = await rpcRemote.updateNeighbors([])
         expect(res.peerDescriptors.length).toEqual(1)
     })
 })