@streamr/trackerless-network 100.0.0-testnet-one.4 → 100.0.0-testnet-two.1

package/test/integration/DeliveryRpcRemote.test.ts

@@ -13,7 +13,6 @@ import {
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 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'
@@ -73,7 +72,8 @@ describe('DeliveryRpcRemote', () => {
             clientNode,
             serverNode,
             STREAM_PART_ID,
-            toProtoRpcClient(new DeliveryRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            DeliveryRpcClient
         )
     })
 
@@ -97,7 +97,7 @@ describe('DeliveryRpcRemote', () => {
     })
 
     it('leaveNotice', async () => {
-        rpcRemote.leaveStreamPartNotice()
+        rpcRemote.leaveStreamPartNotice(false)
         await waitForCondition(() => recvCounter === 1)
     })
 

package/test/integration/HandshakeRpcRemote.test.ts

@@ -9,7 +9,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -34,7 +33,6 @@ describe('HandshakeRpcRemote', () => {
     let mockConnectionManager2: SimulatorTransport
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator()
         mockConnectionManager1 = new SimulatorTransport(serverNode, simulator)
         await mockConnectionManager1.start()
@@ -61,7 +59,8 @@ describe('HandshakeRpcRemote', () => {
             clientNode,
             serverNode,
             'test-stream-part',
-            toProtoRpcClient(new HandshakeRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            HandshakeRpcClient
         )
     })
 
@@ -71,7 +70,6 @@ describe('HandshakeRpcRemote', () => {
         await mockConnectionManager1.stop()
         await mockConnectionManager2.stop()
         simulator.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('handshake', async () => {

package/test/integration/Handshakes.test.ts

@@ -6,7 +6,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -70,7 +69,6 @@ describe('Handshakes', () => {
     let simulatorTransport3: SimulatorTransport
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator()
         simulatorTransport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await simulatorTransport1.start()
@@ -107,7 +105,6 @@ describe('Handshakes', () => {
         await simulatorTransport2.stop()
         await simulatorTransport3.stop()
         simulator.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('Two nodes can handshake', async () => {
@@ -118,7 +115,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
@@ -133,7 +131,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)
@@ -148,7 +147,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(false)
@@ -164,7 +164,8 @@ describe('Handshakes', () => {
                 peerDescriptor2,
                 peerDescriptor1,
                 streamPartId,
-                toProtoRpcClient(new HandshakeRpcClient(rpcCommunicator2.getRpcClientTransport()))
+                rpcCommunicator2,
+                HandshakeRpcClient
             )
         )
         expect(res).toEqual(true)

package/test/integration/Inspect.test.ts

@@ -38,7 +38,6 @@ describe('inspect', () => {
     }
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         simulator = new Simulator(LatencyType.REAL)
 
         publisherNode = await initiateNode(publisherDescriptor, simulator)
@@ -65,7 +64,6 @@ describe('inspect', () => {
             inspectorNode.stop(),
             ...inspectedNodes.map((node) => node.stop())
         ])
-        Simulator.useFakeTimers(false)
     })
 
     it('gets successful inspections from all suspects', async () => {

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -5,7 +5,6 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
 import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
@@ -64,7 +63,8 @@ describe('NeighborUpdateRpcRemote', () => {
             clientNode,
             serverNode,
             'test-stream-part',
-            toProtoRpcClient(new NeighborUpdateRpcClient(clientRpc.getRpcClientTransport()))
+            clientRpc,
+            NeighborUpdateRpcClient
         )
     })
 

package/test/integration/NetworkNode.test.ts

@@ -30,7 +30,6 @@ describe('NetworkNode', () => {
     }
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator()
         transport1 = new SimulatorTransport(pd1, simulator)
         await transport1.start()
@@ -63,7 +62,6 @@ describe('NetworkNode', () => {
             node1.stop(),
             node2.stop()
         ])
-        Simulator.useFakeTimers(false)
     })
 
     it('wait for join + broadcast and subscribe', async () => {

package/test/integration/NetworkRpc.test.ts

@@ -9,7 +9,6 @@ import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { createStreamMessage } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Simulator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
@@ -20,7 +19,6 @@ describe('Network RPC', () => {
     let recvCounter = 0
 
     beforeEach(() => {
-        Simulator.useFakeTimers()
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator2 = new RpcCommunicator()
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
@@ -40,7 +38,6 @@ describe('Network RPC', () => {
     afterEach(() => {
         rpcCommunicator1.stop()
         rpcCommunicator2.stop()
-        Simulator.useFakeTimers(false)
     })
 
     it('sends Data', async () => {

package/test/integration/RandomGraphNode-Layer1Node-Latencies.test.ts

@@ -19,7 +19,6 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
 
     const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => createMockPeerDescriptor())
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator(LatencyType.FIXED, 50)
         const entrypointCm = new SimulatorTransport(entrypointDescriptor, simulator)
         const cms: SimulatorTransport[] = range(numOfNodes).map((i) =>
@@ -43,14 +42,16 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
             layer1Node: layer1Nodes[i],
             transport: cms[i],
             connectionLocker: cms[i],
-            localPeerDescriptor: peerDescriptors[i]
+            localPeerDescriptor: peerDescriptors[i],
+            isLocalNodeEntryPoint: () => false
         }))
         entryPointRandomGraphNode = createRandomGraphNode({
             streamPartId,
             layer1Node: dhtEntryPoint,
             transport: entrypointCm,
             connectionLocker: entrypointCm,
-            localPeerDescriptor: entrypointDescriptor
+            localPeerDescriptor: entrypointDescriptor,
+            isLocalNodeEntryPoint: () => false
         })
 
         await dhtEntryPoint.start()
@@ -63,7 +64,6 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         entryPointRandomGraphNode.stop()
         await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
-        Simulator.useFakeTimers(false)
     })
 
     it('happy path single node', async () => {

package/test/integration/RandomGraphNode-Layer1Node.test.ts

@@ -27,8 +27,6 @@ describe('RandomGraphNode-DhtNode', () => {
         })
     })
     beforeEach(async () => {
-
-        Simulator.useFakeTimers()
         const simulator = new Simulator()
         const entrypointCm = new SimulatorTransport(
             entrypointDescriptor,
@@ -62,7 +60,8 @@ describe('RandomGraphNode-DhtNode', () => {
             transport: cms[i],
             connectionLocker: cms[i],
             localPeerDescriptor: peerDescriptors[i],
-            neighborUpdateInterval: 2000
+            neighborUpdateInterval: 2000,
+            isLocalNodeEntryPoint: () => false
         }))
 
         entryPointRandomGraphNode = createRandomGraphNode({
@@ -71,7 +70,8 @@ describe('RandomGraphNode-DhtNode', () => {
             transport: entrypointCm,
             connectionLocker: entrypointCm,
             localPeerDescriptor: entrypointDescriptor,
-            neighborUpdateInterval: 2000
+            neighborUpdateInterval: 2000,
+            isLocalNodeEntryPoint: () => false
         })
 
         await dhtEntryPoint.start()
@@ -84,7 +84,6 @@ describe('RandomGraphNode-DhtNode', () => {
         entryPointRandomGraphNode.stop()
         await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
-        Simulator.useFakeTimers(false)
     })
 
     it('happy path single node ', async () => {

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -43,7 +43,6 @@ describe('stream without default entrypoints', () => {
     })
 
     beforeEach(async () => {
-        Simulator.useFakeTimers()
         const simulator = new Simulator(LatencyType.REAL)
         nodes = []
         numOfReceivedMessages = 0
@@ -76,7 +75,6 @@ describe('stream without default entrypoints', () => {
     afterEach(async () => {
         await entrypoint.stop()
         await Promise.all(nodes.map((node) => node.stop()))
-        Simulator.useFakeTimers(false)
     })
 
     it('can join stream without configured entrypoints one by one', async () => {
@@ -105,14 +103,13 @@ describe('stream without default entrypoints', () => {
         const numOfSubscribers = 8
         await Promise.all(range(numOfSubscribers).map(async (i) => {
             await nodes[i].join(STREAM_PART_ID, { minCount: 4, timeout: 15000 })
-            nodes[i].addMessageListener((_msg) => {
+            nodes[i].addMessageListener(() => {
                 numOfReceivedMessages += 1
             })
         }))
-        await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000),
-            nodes[9].broadcast(streamMessage)
-        ])
+        const nonjoinedNode = nodes[numOfSubscribers]
+        await nonjoinedNode.broadcast(streamMessage)
+        await waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000)
     }, 45000)
 
     it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {

package/test/integration/streamEntryPointReplacing.test.ts

@@ -0,0 +1,94 @@
+import { Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
+import { NetworkStack } from '../../src/NetworkStack'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { ENTRYPOINT_STORE_LIMIT } from '../../src/logic/EntryPointDiscovery'
+import { range } from 'lodash'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { waitForCondition } from '@streamr/utils'
+import { randomEthereumAddress } from '@streamr/test-utils'
+
+describe('Stream Entry Points are replaced when known entry points leave streams', () => {
+    
+    let simulator: Simulator
+    let layer0EntryPoint: NetworkStack
+    const entryPointPeerDescriptor = createMockPeerDescriptor()
+    let initialNodesOnStream: NetworkStack[]
+    let laterNodesOnStream: NetworkStack[]
+    let newNodeInStream: NetworkStack
+
+    const NUM_OF_LATER_NODES = 16
+
+    const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
+    const startNode = async () => {
+        const peerDescriptor = createMockPeerDescriptor()
+        const transport = new SimulatorTransport(peerDescriptor, simulator)
+        await transport.start()
+        const node = new NetworkStack({
+            layer0: {
+                transport,
+                peerDescriptor,
+                entryPoints: [entryPointPeerDescriptor]
+            }
+        })
+        await node.start()
+        return node
+    }
+
+    beforeEach(async () => {
+        simulator = new Simulator(LatencyType.REAL)
+        const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
+        layer0EntryPoint = new NetworkStack({
+            layer0: {
+                transport: entryPointTransport,
+                peerDescriptor: entryPointPeerDescriptor,
+                entryPoints: [entryPointPeerDescriptor]
+            }
+        })
+        await entryPointTransport.start()
+        await layer0EntryPoint.start()
+
+        initialNodesOnStream = await Promise.all(range(ENTRYPOINT_STORE_LIMIT).map(async () => {
+            return await startNode()
+        }))
+
+        laterNodesOnStream = await Promise.all(range(NUM_OF_LATER_NODES).map(async () => {
+            return await startNode()
+        }))
+        newNodeInStream = await startNode()
+    })
+
+    afterEach(async () => {
+        await Promise.all([
+            layer0EntryPoint.stop(),
+            ...initialNodesOnStream.map((node) => node.stop()),
+            ...laterNodesOnStream.map((node) => node.stop()),
+            newNodeInStream.stop()
+        ])
+        simulator.stop()
+    })
+
+    it('stream entry points are replaced when nodes leave streams', async () => {
+        // TODO: Investigate why CI needs more than 15 seconds to find 4 neighbors for the stream.
+        await Promise.all(initialNodesOnStream.map((node) => node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 })))
+
+        let receivedMessages = 0
+        for (const node of laterNodesOnStream) {
+            await node.joinStreamPart(STREAM_PART_ID, { minCount: 4, timeout: 30000 }) 
+            node.getStreamrNode().on('newMessage', () => {
+                receivedMessages += 1
+            })
+        }
+
+        await Promise.all(initialNodesOnStream.map((node) => node.getStreamrNode().leaveStreamPart(STREAM_PART_ID)))
+        await waitForCondition(() => laterNodesOnStream.every((node) => node.getStreamrNode().getNeighbors(STREAM_PART_ID).length >= 4), 30000, 1000)
+
+        const msg = createStreamMessage(
+            JSON.stringify({ hello: 'WORLD' }),
+            STREAM_PART_ID,
+            randomEthereumAddress()
+        )
+        newNodeInStream.getStreamrNode().broadcast(msg)
+        await waitForCondition(() => receivedMessages === NUM_OF_LATER_NODES, 15000)
+    }, 200000)
+})

package/test/unit/DeliveryRpcLocal.test.ts

@@ -50,7 +50,8 @@ describe('DeliveryRpcLocal', () => {
 
     it('Server leaveStreamPartNotice()', async () => {
         const leaveNotice: LeaveStreamPartNotice = {
-            streamPartId: StreamPartIDUtils.parse('stream#0')
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
+            isEntryPoint: false
         }
         await rpcLocal.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
         expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)

package/test/unit/EntrypointDiscovery.test.ts

@@ -22,7 +22,7 @@ describe('EntryPointDiscovery', () => {
     const fakeData: DataEntry = {
         key: Uint8Array.from([1, 2, 3]),
         data: Any.pack(peerDescriptor, PeerDescriptor),
-        creator: peerDescriptor,
+        creator: peerDescriptor.nodeId,
         ttl: 1000,
         stale: false,
         deleted: false
@@ -31,7 +31,7 @@ describe('EntryPointDiscovery', () => {
     const fakeDeletedData: DataEntry = {
         key: Uint8Array.from([1, 2, 3]),
         data: Any.pack(deletedPeerDescriptor, PeerDescriptor),
-        creator: deletedPeerDescriptor,
+        creator: deletedPeerDescriptor.nodeId,
         ttl: 1000,
         stale: false,
         deleted: true
@@ -112,17 +112,20 @@ describe('EntryPointDiscovery', () => {
     it('store on empty stream', async () => {
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('store on stream without saturated entrypoint count', async () => {
         addNodesToStreamPart(layer1Node, 4)
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
     })
 
     it('will keep stored until destroyed', async () => {
         await entryPointDiscoveryWithData.storeSelfAsEntryPointIfNecessary(0)
         expect(storeCalled).toEqual(1)
+        expect(entryPointDiscoveryWithData.isLocalNodeEntryPoint()).toEqual(true)
         await wait(4500)
         await entryPointDiscoveryWithData.destroy()
         // we have configured storeInterval to 2 seconds, i.e. after 4.5 seconds it should have been called 2 more items 

package/test/unit/HandshakeRpcLocal.test.ts

@@ -3,7 +3,7 @@ import { hexToBinary } from '@streamr/utils'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
-import { InterleaveNotice, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor, createMockHandshakeRpcRemote, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
@@ -17,18 +17,20 @@ describe('HandshakeRpcLocal', () => {
 
     let targetNeighbors: NodeList
     let ongoingHandshakes: Set<NodeID>
+    let ongoingInterleaves: Set<NodeID>
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
         targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
         ongoingHandshakes = new Set()
-
+        ongoingInterleaves = new Set()
         handshakeWithInterleaving = jest.fn()
 
         rpcLocal = new HandshakeRpcLocal({
             streamPartId: STREAM_PART_ID,
             connectionLocker: mockConnectionLocker,
             ongoingHandshakes,
+            ongoingInterleaves,
             createRpcRemote: (_p) => createMockHandshakeRpcRemote(),
             createDeliveryRpcRemote: (_p) => createMockDeliveryRpcRemote(),
             handshakeWithInterleaving: async (_p, _t) => {
@@ -85,31 +87,67 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveNotice = {
-            streamPartId: STREAM_PART_ID,
+        const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
                 nodeId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
-
         }
-        await rpcLocal.interleaveNotice(req, {
+        await rpcLocal.interleaveRequest(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
     })
 
     it('handshakeWithInterleaving success', async () => {
-        const req: InterleaveNotice = {
-            streamPartId: StreamPartIDUtils.parse('other-stream#0'),
+        const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
                 nodeId: hexToBinary('0x2222'),
                 type: NodeType.NODEJS
             }
         }
-        await rpcLocal.interleaveNotice(req, {
+        await rpcLocal.interleaveRequest(req, {
+            incomingSourceDescriptor: createMockPeerDescriptor()
+        } as any)
+        expect(handshakeWithInterleaving).toHaveBeenCalledTimes(1)
+    })
+
+    it('rejects handshakes if interleaving to the requestor is ongoing', async () => {
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        const requestor = createMockPeerDescriptor()
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(requestor))
+        const req = StreamPartHandshakeRequest.create({
+            streamPartId: STREAM_PART_ID,
+            requestId: 'requestId'
+        })
+        const res = await rpcLocal.handshake(req, {
+            incomingSourceDescriptor: requestor
+        } as any)
+        expect(res.accepted).toEqual(false)
+    })
+
+    it('Rejects if interleaving is required and too many interleaving requests are ongoing', async () => {
+        const interleavingPeer1 = createMockPeerDescriptor()
+        const interleavingPeer2 = createMockPeerDescriptor()
+        const interleavingPeer3 = createMockPeerDescriptor()
+        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer1))
+        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer2))
+        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer3))
+        targetNeighbors.add(createMockDeliveryRpcRemote())
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
+        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer3))
+        const req = StreamPartHandshakeRequest.create({
+            streamPartId: STREAM_PART_ID,
+            requestId: 'requestId'
+        })
+        const res = await rpcLocal.handshake(req, {
             incomingSourceDescriptor: createMockPeerDescriptor()
         } as any)
+        expect(res.accepted).toEqual(false)
         expect(handshakeWithInterleaving).toHaveBeenCalledTimes(0)
     })
 

package/test/unit/NodeList.test.ts

@@ -1,20 +1,19 @@
-import { NodeList } from '../../src/logic/NodeList'
-import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import {
-    PeerDescriptor,
     ListeningRpcCommunicator,
+    NodeType,
+    PeerDescriptor,
     Simulator,
     SimulatorTransport,
-    NodeType,
 } from '@streamr/dht'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { binaryToHex } from '@streamr/utils'
 import { expect } from 'expect'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { createMockPeerDescriptor, createRandomNodeId } from '../utils/utils'
-import { binaryToHex } from '@streamr/utils'
-import { StreamPartIDUtils } from '@streamr/protocol'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { NodeList } from '../../src/logic/NodeList'
 import { formStreamPartDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { createMockPeerDescriptor, createRandomNodeId } from '../utils/utils'
 
 const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -36,14 +35,13 @@ describe('NodeList', () => {
         const mockTransport = new SimulatorTransport(peerDescriptor, simulator)
         await mockTransport.start()
         const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), mockTransport)
-        const mockClient = mockCommunicator.getRpcClientTransport()
-        
         mockTransports.push(mockTransport)
         return new DeliveryRpcRemote(
             createMockPeerDescriptor(),
             peerDescriptor,
             streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(mockClient))
+            mockCommunicator,
+            DeliveryRpcClient
         )
     }
 

package/test/unit/ProxyConnectionRpcRemote.test.ts

@@ -1,30 +1,38 @@
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
-import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRequest, ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('ProxyConnectionRpcRemote', () => {
 
-    it('happy path', () => {
-        const client = {
-            requestConnection: jest.fn()
-        }
+    it('happy path', async () => {
+        const onOutgoingMessage = jest.fn()
+        const rpcCommunicator = new RpcCommunicator()
+        rpcCommunicator.setOutgoingMessageListener(onOutgoingMessage)
         const clientPeerDescriptor = createMockPeerDescriptor()
         const serverPeerDescriptor = createMockPeerDescriptor()
         const rpcRemote = new ProxyConnectionRpcRemote(
             clientPeerDescriptor,
             serverPeerDescriptor,
             StreamPartIDUtils.parse('stream#0'),
-            client
+            rpcCommunicator,
+            ProxyConnectionRpcClient
         )
+
         const userId = randomEthereumAddress()
-        rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
-        expect(client.requestConnection).toBeCalledWith({
+        await rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
+
+        const [rpcMessage, _, callContext] = onOutgoingMessage.mock.calls[0]
+        const request = ProxyConnectionRequest.fromBinary(rpcMessage.body.value)
+        expect(request).toEqual({
             direction: ProxyDirection.PUBLISH,
-            userId: hexToBinary(userId)
-        }, {
+            userId: Uint8Array.from(hexToBinary(userId))
+        })
+        expect(callContext).toMatchObject({
             sourceDescriptor: clientPeerDescriptor,
             targetDescriptor: serverPeerDescriptor,
             timeout: 5000