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

package/test/end-to-end/proxy-and-full-node.test.ts

@@ -1,5 +1,5 @@
 import { randomUserId } from '@streamr/test-utils'
-import { StreamPartID, StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
+import { StreamPartID, StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import {
     ContentType,
@@ -7,7 +7,7 @@ import {
     ProxyDirection,
     SignatureType,
     StreamMessage
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const PROXIED_NODE_USER_ID = randomUserId()
@@ -19,7 +19,7 @@ const createMessage = (streamPartId: StreamPartID): StreamMessage => {
             streamPartition: StreamPartIDUtils.getStreamPartition(streamPartId),
             timestamp: 666,
             sequenceNumber: 0,
-            publisherId: hexToBinary(randomUserId()),
+            publisherId: toUserIdRaw(randomUserId()),
             messageChainId: 'msgChainId'
         },
         previousMessageRef: {

package/test/end-to-end/proxy-connections.test.ts

@@ -1,6 +1,6 @@
 import { DhtAddress } from '@streamr/dht'
 import { randomUserId } from '@streamr/test-utils'
-import { StreamPartIDUtils, hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { StreamPartIDUtils, hexToBinary, toUserIdRaw, utf8ToBinary, wait, until, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
@@ -10,7 +10,7 @@ import {
     ProxyDirection,
     SignatureType,
     StreamMessage
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+} from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const PROXIED_NODE_USER_ID = randomUserId()
@@ -21,7 +21,7 @@ const MESSAGE: StreamMessage = {
         streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
         timestamp: 666,
         sequenceNumber: 0,
-        publisherId: hexToBinary(randomUserId()),
+        publisherId: toUserIdRaw(randomUserId()),
         messageChainId: 'msgChainId'
     },
     previousMessageRef: {
@@ -79,7 +79,6 @@ describe('Proxy connections', () => {
             }
         })
         await proxyNode1.start()
-        proxyNode1.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
         proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         proxyNode2 = createNetworkNode({
             layer0: {
@@ -92,7 +91,6 @@ describe('Proxy connections', () => {
             }
         })
         await proxyNode2.start()
-        proxyNode2.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
         proxyNode2.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         proxiedNode = createNetworkNode({
             layer0: {
@@ -131,7 +129,7 @@ describe('Proxy connections', () => {
         expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
         await proxiedNode.setProxies(STREAM_PART_ID, [], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 0)
         expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(false) 
-        await waitForCondition(() => hasConnectionFromProxy(proxyNode1) === false)
+        await until(() => hasConnectionFromProxy(proxyNode1) === false)
     })
 
     it('can leave proxy subscribe connection', async () => {
@@ -140,7 +138,7 @@ describe('Proxy connections', () => {
         expect(hasConnectionFromProxy(proxyNode1)).toBe(true) 
         await proxiedNode.setProxies(STREAM_PART_ID, [], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID, 0)
         expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(false)
-        await waitForCondition(() => hasConnectionFromProxy(proxyNode1) === false)
+        await until(() => hasConnectionFromProxy(proxyNode1) === false)
     })
 
     it('can open multiple proxy connections', async () => {
@@ -167,7 +165,7 @@ describe('Proxy connections', () => {
         expect(hasConnectionFromProxy(proxyNode2)).toBe(true)
         await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID)
         expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
-        await waitForCondition(() => hasConnectionFromProxy(proxyNode2) === false)
+        await until(() => hasConnectionFromProxy(proxyNode2) === false)
         expect(hasConnectionFromProxy(proxyNode1)).toBe(true)
     })
 
@@ -184,8 +182,8 @@ describe('Proxy connections', () => {
 
         await proxiedNode.setProxies(STREAM_PART_ID, [], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID)
         expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(false)
-        await waitForCondition(() => hasConnectionFromProxy(proxyNode1) === false)
-        await waitForCondition(() => hasConnectionFromProxy(proxyNode2) === false)
+        await until(() => hasConnectionFromProxy(proxyNode1) === false)
+        await until(() => hasConnectionFromProxy(proxyNode2) === false)
     })
 
     it('will reconnect if proxy node goes offline and comes back online', async () => {
@@ -197,10 +195,10 @@ describe('Proxy connections', () => {
         )
         expect(proxiedNode.hasStreamPart(STREAM_PART_ID)).toBe(true)
         await proxyNode1.leave(STREAM_PART_ID)
-        await waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE))
+        await until(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE))
         expect(hasConnectionFromProxy(proxyNode1)).toBe(false)
         proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
-        await waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE), 25000)
+        await until(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE), 25000)
         // TODO why wait is needed?
         await wait(100)
         expect(hasConnectionFromProxy(proxyNode1)).toBe(true)

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

@@ -2,10 +2,11 @@ import { randomUserId } from '@streamr/test-utils'
 import {
     StreamPartIDUtils,
     hexToBinary,
+    toUserIdRaw,
     waitForEvent3
 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { ProxyDirection, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyDirection, SignatureType, StreamMessage } from '../../generated/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
@@ -36,7 +37,6 @@ describe('proxy group key exchange', () => {
             }
         })
         await proxyNode.start()
-        proxyNode.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor])
         proxyNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         publisher = createNetworkNode({
             layer0: {
@@ -71,14 +71,14 @@ describe('proxy group key exchange', () => {
                 streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 timestamp: Date.now(),
                 sequenceNumber: 0,
-                publisherId: hexToBinary(subscriberUserId),
+                publisherId: toUserIdRaw(subscriberUserId),
                 messageChainId: '0'
             },
             body: {
                 oneofKind: 'groupKeyRequest' as const,
                 groupKeyRequest: {
                     requestId: 'requestId',
-                    recipientId: hexToBinary(publisherUserId),
+                    recipientId: toUserIdRaw(publisherUserId),
                     rsaPublicKey: new Uint8Array(),
                     groupKeyIds: ['mock']
                 }
@@ -103,14 +103,14 @@ describe('proxy group key exchange', () => {
                 streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 timestamp: Date.now(),
                 sequenceNumber: 0,
-                publisherId: hexToBinary(publisherUserId),
+                publisherId: toUserIdRaw(publisherUserId),
                 messageChainId: '0'
             },
             body: {
                 oneofKind: 'groupKeyResponse' as const,
                 groupKeyResponse: {
                     requestId: 'requestId',
-                    recipientId: hexToBinary(publisherUserId),
+                    recipientId: toUserIdRaw(publisherUserId),
                     groupKeys: []
                 }
             },

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

@@ -1,5 +1,5 @@
 import { toNodeId, getRandomRegion } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
@@ -32,7 +32,6 @@ describe('Full node network with WebRTC connections', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
         entryPoint.getContentDeliveryManager().joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async () => {
@@ -45,7 +44,6 @@ describe('Full node network with WebRTC connections', () => {
             })
             nodes.push(node)
             await node.start()
-            node.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
             node.getContentDeliveryManager().joinStreamPart(streamPartId)
         }))
 
@@ -60,7 +58,7 @@ describe('Full node network with WebRTC connections', () => {
 
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
-            waitForCondition(() => {
+            until(() => {
                 return node.getContentDeliveryManager().getNeighbors(streamPartId).length >= 3
             }
             , 30000)
@@ -79,7 +77,7 @@ describe('Full node network with WebRTC connections', () => {
             randomUserId()
         )
         entryPoint.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
+        await until(() => receivedMessageCount === NUM_OF_NODES)
     }, 120000)
 
 })

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

@@ -1,5 +1,5 @@
 import { toNodeId } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, until } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
@@ -7,7 +7,7 @@ import { randomUserId } from '@streamr/test-utils'
 
 describe('Full node network with WebSocket connections only', () => {
 
-    const NUM_OF_NODES = 20
+    const NUM_OF_NODES = 12
     const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 15555, tls: false }
     })
@@ -29,7 +29,6 @@ describe('Full node network with WebSocket connections only', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
         entryPoint.getContentDeliveryManager().joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async (i) => {
@@ -43,7 +42,6 @@ describe('Full node network with WebSocket connections only', () => {
             })
             nodes.push(node)
             await node.start()
-            node.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
             node.getContentDeliveryManager().joinStreamPart(streamPartId)
         }))
 
@@ -58,7 +56,7 @@ describe('Full node network with WebSocket connections only', () => {
 
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
-            waitForCondition(() => {
+            until(() => {
                 return node.getContentDeliveryManager().getNeighbors(streamPartId).length >= 4
             }
             , 30000)
@@ -78,7 +76,7 @@ describe('Full node network with WebSocket connections only', () => {
             randomUserId()
         )
         entryPoint.getContentDeliveryManager().broadcast(msg)
-        await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
+        await until(() => receivedMessageCount === NUM_OF_NODES)
     }, 220000)
 
 })

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

@@ -1,5 +1,5 @@
 import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport, toNodeId } from '@streamr/dht'
-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'
@@ -72,8 +72,8 @@ describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
         await otherContentDeliveryLayerNodes[0].start()
         await otherDiscoveryLayerNodes[0].joinDht([entrypointDescriptor])
         await Promise.all([
-            waitForCondition(() => otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length === 1),
-            waitForCondition(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
+            until(() => otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length === 1),
+            until(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
         ])
         expect(otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
         expect(otherContentDeliveryLayerNodes[0].getNeighbors().length).toEqual(1)
@@ -84,7 +84,7 @@ describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
         await Promise.all(range(4).map(async (i) => {
             await otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
         }))
-        await waitForCondition(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length >= 4), 15000, 1000)
+        await until(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length >= 4), 15000, 1000)
         range(4).forEach((i) => {
             expect(otherContentDeliveryLayerNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
             expect(otherContentDeliveryLayerNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
@@ -110,14 +110,14 @@ describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
             otherDiscoveryLayerNodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
-            waitForCondition(() => node.getNeighbors().length >= 4, 10000)
+            until(() => node.getNeighbors().length >= 4, 10000)
         ))
 
         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()

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

@@ -1,5 +1,5 @@
 import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, toNodeId, getRandomRegion } from '@streamr/dht'
-import { Logger, StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+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)
@@ -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,9 +138,9 @@ 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()

package/test/integration/ContentDeliveryManager.test.ts

@@ -3,7 +3,7 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-import { StreamPartIDUtils, waitForCondition, waitForEvent3, wait } 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'
@@ -84,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)
     })
@@ -93,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)
         ])
     })
@@ -110,10 +111,10 @@ 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' }),
@@ -123,7 +124,9 @@ describe('ContentDeliveryManager', () => {
         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)
         ])
     })
@@ -132,19 +135,19 @@ 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([
-            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)
         ])
         // Wait for RTTs to be updated
         await wait(500)

package/test/integration/ContentDeliveryRpcRemote.test.ts

@@ -5,14 +5,14 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
-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'
 
@@ -89,12 +89,12 @@ describe('ContentDeliveryRpcRemote', () => {
         )
 
         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

@@ -8,12 +8,10 @@ import {
 } 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', () => {
 
@@ -86,6 +84,12 @@ describe('Handshakes', () => {
         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,64 +116,25 @@ 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(toNodeId(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)
+        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)
+        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)
+        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/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,9 +1,9 @@
 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'
-import { randomUserId } from '@streamr/test-utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
 
@@ -63,7 +63,7 @@ describe('NetworkNode', () => {
                 streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
                 timestamp: 666,
                 sequenceNumber: 0,
-                publisherId: hexToBinary(randomUserId()),
+                publisherId: toUserIdRaw(randomUserId()),
                 messageChainId: 'msgChainId'
             },
             previousMessageRef: {
@@ -92,7 +92,7 @@ describe('NetworkNode', () => {
             msgCount += 1
         })
         await node2.broadcast(streamMessage)
-        await waitForCondition(() => msgCount === 1)
+        await until(() => msgCount === 1)
     })
 
     it('fetchNodeInfo', async () => {