@streamr/trackerless-network 101.1.2 → 102.0.0-beta.1

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

@@ -1,5 +1,5 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
-import { Logger, StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, toNodeId, getRandomRegion } from '@streamr/dht'
+import { Logger, StreamPartIDUtils, until } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
@@ -92,7 +92,7 @@ describe('ContentDeliveryLayerNode-DhtNode', () => {
         await otherContentDeliveryLayerNodes[0].start()
         await otherDiscoveryLayerNodes[0].joinDht([entrypointDescriptor])
 
-        await waitForCondition(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
+        await until(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
         expect(otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
         expect(otherContentDeliveryLayerNodes[0].getNeighbors().length).toEqual(1)
     })
@@ -103,7 +103,7 @@ describe('ContentDeliveryLayerNode-DhtNode', () => {
             await otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
         }))
 
-        await waitForCondition(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length === 4))
+        await until(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length === 4))
         range(4).forEach((i) => {
             expect(otherContentDeliveryLayerNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
             expect(otherContentDeliveryLayerNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
@@ -117,7 +117,7 @@ describe('ContentDeliveryLayerNode-DhtNode', () => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === nodeId
                 })
-                const neighborNodeIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                const neighborNodeIds = neighbor!.getNeighbors().map((n) => toNodeId(n))
                 expect(neighborNodeIds.includes(allNodes[i].getOwnNodeId())).toEqual(true)
             })
         })
@@ -129,7 +129,7 @@ describe('ContentDeliveryLayerNode-DhtNode', () => {
             otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            waitForCondition(() => node.getNeighbors().length >= 4, 10000)
+            until(() => node.getNeighbors().length >= 4, 10000)
         ))
 
         const avg = otherContentDeliveryLayerNodes.reduce((acc, curr) => {
@@ -138,17 +138,17 @@ describe('ContentDeliveryLayerNode-DhtNode', () => {
 
         logger.info(`AVG Number of neighbors: ${avg}`)
         await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            waitForCondition(() => node.getOutgoingHandshakeCount() === 0)
+            until(() => node.getOutgoingHandshakeCount() === 0)
         ))
-        await waitForCondition(() => {
+        await until(() => {
             let mismatchCounter = 0
             otherContentDeliveryLayerNodes.forEach((node) => {
                 const nodeId = node.getOwnNodeId()
                 node.getNeighbors().forEach((neighbor) => {
-                    const neighborId = getNodeIdFromPeerDescriptor(neighbor)
+                    const neighborId = toNodeId(neighbor)
                     if (neighborId !== entryPointContentDeliveryLayerNode.getOwnNodeId()) {
                         const neighbor = otherContentDeliveryLayerNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        const neighborNodeIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                        const neighborNodeIds = neighbor!.getNeighbors().map((n) => toNodeId(n))
                         if (!neighborNodeIds.includes(nodeId)) {
                             mismatchCounter += 1
                         }

package/test/integration/ContentDeliveryManager.test.ts

@@ -3,11 +3,11 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { StreamPartIDUtils, until, waitForEvent3, wait } from '@streamr/utils'
 import { ContentDeliveryManager, Events } from '../../src/logic/ContentDeliveryManager'
 import { ControlLayerNode } from '../../src/logic/ControlLayerNode'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('ContentDeliveryManager', () => {
 
@@ -25,18 +25,12 @@ describe('ContentDeliveryManager', () => {
     const msg = createStreamMessage(
         JSON.stringify({ hello: 'WORLD' }),
         STREAM_PART_ID,
-        randomEthereumAddress()
+        randomUserId()
     )
-
-    afterEach(async () => {
-        await Promise.all([
-            manager1.destroy(),
-            manager2.destroy()
-        ])
-    })
+    let simulator: Simulator
 
     beforeEach(async () => {
-        const simulator = new Simulator()
+        simulator = new Simulator()
         transport1 = new SimulatorTransport(peerDescriptor1, simulator)
         await transport1.start()
         transport2 = new SimulatorTransport(peerDescriptor2, simulator)
@@ -62,14 +56,26 @@ describe('ContentDeliveryManager', () => {
             controlLayerNode2.joinDht([peerDescriptor1])
         ])
 
-        manager1 = new ContentDeliveryManager({})
-        manager2 = new ContentDeliveryManager({})
+        manager1 = new ContentDeliveryManager({ neighborUpdateInterval: 100 })
+        manager2 = new ContentDeliveryManager({ neighborUpdateInterval: 100 })
         await manager1.start(controlLayerNode1, transport1, transport1)
         manager1.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
         await manager2.start(controlLayerNode2, transport2, transport2)
         manager2.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
     })
 
+    afterEach(async () => {
+        await Promise.all([
+            manager1.destroy(),
+            manager2.destroy(),
+            controlLayerNode1.stop(),
+            controlLayerNode2.stop(),
+            transport1.stop(),
+            transport2.stop()
+        ])
+        simulator.stop()
+    })
+
     it('starts', async () => {
         expect(manager1.getPeerDescriptor()).toEqual(peerDescriptor1)
         expect(manager2.getPeerDescriptor()).toEqual(peerDescriptor2)
@@ -78,8 +84,8 @@ describe('ContentDeliveryManager', () => {
     it('Joining stream', async () => {
         manager1.joinStreamPart(STREAM_PART_ID)
         manager2.joinStreamPart(STREAM_PART_ID)
-        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
-        await waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+        await until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
+        await until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
         expect(manager1.getNeighbors(STREAM_PART_ID).length).toEqual(1)
         expect(manager2.getNeighbors(STREAM_PART_ID).length).toEqual(1)
     })
@@ -87,10 +93,11 @@ describe('ContentDeliveryManager', () => {
     it('Publishing after joining and waiting for neighbors', async () => {
         manager1.joinStreamPart(STREAM_PART_ID)
         manager2.joinStreamPart(STREAM_PART_ID)
-        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
-        await waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+        await until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1)
+        await until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
         await Promise.all([
             waitForEvent3<Events>(manager1, 'newMessage'),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             manager2.broadcast(msg)
         ])
     })
@@ -104,20 +111,22 @@ describe('ContentDeliveryManager', () => {
         manager2.joinStreamPart(STREAM_PART_ID)
         manager2.joinStreamPart(streamPartId2)
         await Promise.all([
-            waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
-            waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1),
-            waitForCondition(() => manager1.getNeighbors(streamPartId2).length === 1),
-            waitForCondition(() => manager2.getNeighbors(streamPartId2).length === 1)
+            until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
+            until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1),
+            until(() => manager1.getNeighbors(streamPartId2).length === 1),
+            until(() => manager2.getNeighbors(streamPartId2).length === 1)
         ])
         const msg2 = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             streamPartId2,
-            randomEthereumAddress()
+            randomUserId()
         )
         await Promise.all([
             waitForEvent3<Events>(manager1, 'newMessage'),
             waitForEvent3<Events>(manager2, 'newMessage'),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             manager1.broadcast(msg2),
+            // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
             manager2.broadcast(msg)
         ])
     })
@@ -126,11 +135,26 @@ describe('ContentDeliveryManager', () => {
         manager1.joinStreamPart(STREAM_PART_ID)
         manager2.joinStreamPart(STREAM_PART_ID)
         await Promise.all([
-            waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
-            waitForCondition(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+            until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
+            until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
         ])
         await manager2.leaveStreamPart(STREAM_PART_ID)
-        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 0)
+        await until(() => manager1.getNeighbors(STREAM_PART_ID).length === 0)
+    })
+
+    it('RTTs are updated for node info', async () => {
+        manager1.joinStreamPart(STREAM_PART_ID)
+        manager2.joinStreamPart(STREAM_PART_ID)
+        await Promise.all([
+            until(() => manager1.getNeighbors(STREAM_PART_ID).length === 1),
+            until(() => manager2.getNeighbors(STREAM_PART_ID).length === 1)
+        ])
+        // Wait for RTTs to be updated
+        await wait(500)
+        const nodeInfo1 = manager1.getNodeInfo()
+        const nodeInfo2 = manager2.getNodeInfo()
+        expect(nodeInfo1[0].contentDeliveryLayerNeighbors[0].rtt).toBeGreaterThanOrEqual(0)
+        expect(nodeInfo2[0].contentDeliveryLayerNeighbors[0].rtt).toBeGreaterThanOrEqual(0)
     })
 
 })

package/test/integration/ContentDeliveryRpcRemote.test.ts

@@ -5,16 +5,16 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { Empty } from '../../src/proto/google/protobuf/empty'
+import { Empty } from '../../generated/google/protobuf/empty'
 import {
     LeaveStreamPartNotice,
     StreamMessage
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('ContentDeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
@@ -85,16 +85,16 @@ describe('ContentDeliveryRpcRemote', () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             StreamPartIDUtils.parse('test-stream#0'),
-            randomEthereumAddress()
+            randomUserId()
         )
 
         await rpcRemote.sendStreamMessage(msg)
-        await waitForCondition(() => recvCounter === 1)
+        await until(() => recvCounter === 1)
     })
 
     it('leaveNotice', async () => {
         rpcRemote.leaveStreamPartNotice(StreamPartIDUtils.parse('test#0'), false)
-        await waitForCondition(() => recvCounter === 1)
+        await until(() => recvCounter === 1)
     })
 
 })

package/test/integration/HandshakeRpcRemote.test.ts

@@ -10,10 +10,10 @@ import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/Handshake
 import {
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import {
     HandshakeRpcClient,
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+} from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 
 describe('HandshakeRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator

package/test/integration/Handshakes.test.ts

@@ -4,16 +4,14 @@ import {
     PeerDescriptor,
     Simulator,
     SimulatorTransport,
-    getNodeIdFromPeerDescriptor
+    toNodeId
 } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { NodeList } from '../../src/logic/NodeList'
-import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
 import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
-import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import {
-    HandshakeRpcClient
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
 
 describe('Handshakes', () => {
 
@@ -82,10 +80,16 @@ describe('Handshakes', () => {
         rpcCommunicator2 = new ListeningRpcCommunicator(streamPartId, simulatorTransport2)
         rpcCommunicator3 = new ListeningRpcCommunicator(streamPartId, simulatorTransport3)
 
-        const handshakerNodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
+        const handshakerNodeId = toNodeId(peerDescriptor2)
         leftNodeView = new NodeList(handshakerNodeId, 10)
         rightNodeView = new NodeList(handshakerNodeId, 10)
         nodeView = new NodeList(handshakerNodeId, 10)
+        nodeView.add(new ContentDeliveryRpcRemote(
+            peerDescriptor2,
+            peerDescriptor1,
+            rpcCommunicator2,
+            ContentDeliveryRpcClient
+        ))
         neighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
             localPeerDescriptor: peerDescriptor2,
@@ -112,65 +116,26 @@ describe('Handshakes', () => {
         simulator.stop()
     })
 
-    it('Two nodes can handshake', async () => {
-        rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(true)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
-    })
-
     it('Handshake accepted', async () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(true)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
+        const res = await handshaker.attemptHandshakesOnContacts([])
+        expect(res).toHaveLength(0)
+        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
     })
 
     it('Handshake rejected', async () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', rejectHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(false)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(false)
+        const res = await handshaker.attemptHandshakesOnContacts([])
+        expect(res[0]).toEqual(toNodeId(peerDescriptor1))
+        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(false)
     })
 
     it('Handshake with Interleaving', async () => {
         rpcCommunicator1.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', interleavingHandshake)
         rpcCommunicator3.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake', acceptHandshake)
-        // @ts-expect-error private
-        const res = await handshaker.handshakeWithTarget(
-            new HandshakeRpcRemote(
-                peerDescriptor2,
-                peerDescriptor1,
-                rpcCommunicator2,
-                HandshakeRpcClient
-            )
-        )
-        expect(res).toEqual(true)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor3))).toEqual(true)
+        const res = await handshaker.attemptHandshakesOnContacts([])
+        expect(res).toHaveLength(0)
+        expect(neighbors.has(toNodeId(peerDescriptor1))).toEqual(true)
+        expect(neighbors.has(toNodeId(peerDescriptor3))).toEqual(true)
     })
 })

package/test/integration/Inspect.test.ts

@@ -1,9 +1,9 @@
 import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('inspect', () => {
 
@@ -72,7 +72,7 @@ describe('inspect', () => {
             const msg = createStreamMessage(
                 JSON.stringify({ hello: 'WORLD' }),
                 streamPartId,
-                randomEthereumAddress(),
+                randomUserId(),
                 123123,
                 sequenceNumber
             )

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -7,10 +7,10 @@ import {
 } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
-import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { NeighborUpdate } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import {
     NeighborUpdateRpcClient,
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+} from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 
 describe('NeighborUpdateRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator

package/test/integration/NetworkNode.test.ts

@@ -1,7 +1,8 @@
 import { PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
+import { randomUserId } from '@streamr/test-utils'
+import { StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, until } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
@@ -62,7 +63,7 @@ describe('NetworkNode', () => {
                 streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 timestamp: 666,
                 sequenceNumber: 0,
-                publisherId: hexToBinary('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
+                publisherId: toUserIdRaw(randomUserId()),
                 messageChainId: 'msgChainId'
             },
             previousMessageRef: {
@@ -91,7 +92,7 @@ describe('NetworkNode', () => {
             msgCount += 1
         })
         await node2.broadcast(streamMessage)
-        await waitForCondition(() => msgCount === 1)
+        await until(() => msgCount === 1)
     })
 
     it('fetchNodeInfo', async () => {

package/test/integration/NetworkRpc.test.ts

@@ -4,13 +4,13 @@ import {
     RpcCommunicator,
     toProtoRpcClient
 } from '@streamr/proto-rpc'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
-import { Empty } from '../../src/proto/google/protobuf/empty'
-import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartIDUtils, until } from '@streamr/utils'
+import { Empty } from '../../generated/google/protobuf/empty'
+import { RpcMessage } from '../../generated/packages/proto-rpc/protos/ProtoRpc'
+import { StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../generated/packages/trackerless-network/protos/NetworkRpc.client'
 import { createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('Network RPC', () => {
     let rpcCommunicator1: RpcCommunicator<DhtCallContext>
@@ -21,8 +21,8 @@ describe('Network RPC', () => {
     beforeEach(() => {
         rpcCommunicator1 = new RpcCommunicator()
         rpcCommunicator2 = new RpcCommunicator()
-        rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
-            rpcCommunicator2.handleIncomingMessage(message)
+        rpcCommunicator1.setOutgoingMessageListener(async (message: RpcMessage) => {
+            rpcCommunicator2.handleIncomingMessage(message, new DhtCallContext())
         })
         client = toProtoRpcClient(new ContentDeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
         rpcCommunicator2.registerRpcNotification(
@@ -44,9 +44,9 @@ describe('Network RPC', () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             StreamPartIDUtils.parse('testStream#0'),
-            randomEthereumAddress()
+            randomUserId()
         )
         await client.sendStreamMessage(msg)
-        await waitForCondition(() => recvCounter === 1)
+        await until(() => recvCounter === 1)
     })
 })

package/test/integration/NetworkStack.test.ts

@@ -1,10 +1,10 @@
-import { randomEthereumAddress } from '@streamr/test-utils'
 import {
     StreamPartIDUtils,
-    waitForCondition
+    until
 } from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
@@ -55,10 +55,10 @@ describe('NetworkStack', () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             STREAM_PART_ID,
-            randomEthereumAddress()
+            randomUserId()
         )
         stack2.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => receivedMessages === 1)
+        await until(() => receivedMessages === 1)
     })
 
     it('join and wait for neighbors', async () => {

package/test/integration/NodeInfoRpc.test.ts

@@ -1,5 +1,5 @@
 import { ListeningRpcCommunicator, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
 import { NodeInfoClient } from '../../src/logic/node-info/NodeInfoClient'
 import { NODE_INFO_RPC_SERVICE_ID } from '../../src/logic/node-info/NodeInfoRpcLocal'
@@ -72,7 +72,7 @@ describe('NetworkStack NodeInfoRpc', () => {
         otherStack.getContentDeliveryManager().joinStreamPart(streamPartId1)
         requesteStack.getContentDeliveryManager().joinStreamPart(streamPartId2)
         otherStack.getContentDeliveryManager().joinStreamPart(streamPartId2)
-        await waitForCondition(() => 
+        await until(() => 
             requesteStack.getContentDeliveryManager().getNeighbors(streamPartId1).length === 1 
             && otherStack.getContentDeliveryManager().getNeighbors(streamPartId1).length === 1
             && requesteStack.getContentDeliveryManager().getNeighbors(streamPartId2).length === 1
@@ -89,15 +89,19 @@ describe('NetworkStack NodeInfoRpc', () => {
                 {
                     id: streamPartId1,
                     controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                    contentDeliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                    contentDeliveryLayerNeighbors: [{
+                        peerDescriptor: normalizePeerDescriptor(otherPeerDescriptor)
+                    }]
                 },
                 {
                     id: streamPartId2,
                     controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
-                    contentDeliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                    contentDeliveryLayerNeighbors: [{
+                        peerDescriptor: normalizePeerDescriptor(otherPeerDescriptor)
+                    }]
                 }
             ],
-            version: expect.any(String)
+            applicationVersion: expect.any(String)
         })
         expect(result.streamPartitions.length).toEqual(2)
     })

package/test/integration/Propagation.test.ts

@@ -1,10 +1,10 @@
 import { Simulator } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
 import { createMockContentDeliveryLayerNodeAndDhtNode, createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('Propagation', () => {
     const entryPointDescriptor = createMockPeerDescriptor()
@@ -56,10 +56,10 @@ describe('Propagation', () => {
     })
 
     it('All nodes receive messages', async () => {
-        await waitForCondition(
+        await until(
             () => contentDeliveryLayerNodes.every((node) => node.getNeighbors().length >= 3), 30000
         )
-        await waitForCondition(() => {
+        await until(() => {
             const avg = contentDeliveryLayerNodes.reduce((acc, curr) => {
                 return acc + curr.getNeighbors().length
             }, 0) / contentDeliveryLayerNodes.length
@@ -68,9 +68,9 @@ describe('Propagation', () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             STREAM_PART_ID,
-            randomEthereumAddress()
+            randomUserId()
         )
         contentDeliveryLayerNodes[0].broadcast(msg)
-        await waitForCondition(() => totalReceived >= NUM_OF_NODES, 10000)
+        await until(() => totalReceived >= NUM_OF_NODES, 10000)
     }, 45000)
 })

package/test/integration/joining-streams-on-offline-peers.test.ts

@@ -1,10 +1,10 @@
 import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
 import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { Any } from '../../src/proto/google/protobuf/any'
+import { Any } from '../../generated/google/protobuf/any'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
 
@@ -74,9 +74,9 @@ describe('Joining stream parts on offline nodes', () => {
         
         node1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         node1.getContentDeliveryManager().on('newMessage', () => { messageReceived = true })
-        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), STREAM_PART_ID, randomEthereumAddress())
+        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), STREAM_PART_ID, randomUserId())
         node2.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => messageReceived, 40000)
+        await until(() => messageReceived, 40000)
     }, 60000)
 
 })