@streamr/trackerless-network 0.0.1-tatum.6 → 0.0.1-tatum.8

package/src/proto/packages/trackerless-network/protos/NetworkRpc.ts

@@ -146,9 +146,9 @@ export interface GroupKey {
  */
 export interface StreamPartHandshakeRequest {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
     /**
      * @generated from protobuf field: string requestId = 2;
      */
@@ -188,9 +188,9 @@ export interface StreamPartHandshakeResponse {
  */
 export interface InterleaveNotice {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
     /**
      * this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
      *
@@ -203,18 +203,18 @@ export interface InterleaveNotice {
  */
 export interface LeaveStreamPartNotice {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
 }
 /**
  * @generated from protobuf message NeighborUpdate
  */
 export interface NeighborUpdate {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
     /**
      * @generated from protobuf field: bool removeMe = 2;
      */
@@ -412,7 +412,7 @@ export const GroupKey = new GroupKey$Type();
 class StreamPartHandshakeRequest$Type extends MessageType<StreamPartHandshakeRequest> {
     constructor() {
         super("StreamPartHandshakeRequest", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "concurrentHandshakeTargetId", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
             { no: 4, name: "neighborIds", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
@@ -442,7 +442,7 @@ export const StreamPartHandshakeResponse = new StreamPartHandshakeResponse$Type(
 class InterleaveNotice$Type extends MessageType<InterleaveNotice> {
     constructor() {
         super("InterleaveNotice", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "interleaveTargetDescriptor", kind: "message", T: () => PeerDescriptor }
         ]);
     }
@@ -455,7 +455,7 @@ export const InterleaveNotice = new InterleaveNotice$Type();
 class LeaveStreamPartNotice$Type extends MessageType<LeaveStreamPartNotice> {
     constructor() {
         super("LeaveStreamPartNotice", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }
@@ -467,7 +467,7 @@ export const LeaveStreamPartNotice = new LeaveStreamPartNotice$Type();
 class NeighborUpdate$Type extends MessageType<NeighborUpdate> {
     constructor() {
         super("NeighborUpdate", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "removeMe", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 3, name: "neighborDescriptors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }
         ]);
@@ -525,9 +525,9 @@ class TemporaryConnectionResponse$Type extends MessageType<TemporaryConnectionRe
  */
 export const TemporaryConnectionResponse = new TemporaryConnectionResponse$Type();
 /**
- * @generated ServiceType for protobuf service NetworkRpc
+ * @generated ServiceType for protobuf service DeliveryRpc
  */
-export const NetworkRpc = new ServiceType("NetworkRpc", [
+export const DeliveryRpc = new ServiceType("DeliveryRpc", [
     { name: "sendStreamMessage", options: {}, I: StreamMessage, O: Empty },
     { name: "leaveStreamPartNotice", options: {}, I: LeaveStreamPartNotice, O: Empty }
 ]);

package/test/benchmark/first-message.ts

@@ -1,15 +1,15 @@
 /* eslint-disable no-console */
 
-import { LatencyType, Simulator, getRandomRegion } from '@streamr/dht'
+import { DhtNode, LatencyType, Simulator, getRandomRegion } from '@streamr/dht'
 import { MessageID, StreamMessage, StreamMessageType, StreamPartID, StreamPartIDUtils, toStreamID, toStreamPartID } from '@streamr/protocol'
 import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
 import fs from 'fs'
-import { PeerDescriptor } from '../../../dht/src/exports'
+import { PeerDescriptor } from '@streamr/dht'
 import { NetworkNode } from '../../src/NetworkNode'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { streamPartIdToDataKey } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
-import { ILayer1 } from '../../src/logic/ILayer1'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 
 const numNodes = 10000
@@ -28,8 +28,7 @@ const prepareLayer0 = async () => {
     nodes = []
     simulator = new Simulator(LatencyType.REAL)
     const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion(),
-        nodeName: 'entrypoint'
+        region: getRandomRegion()
     })
     layer0Ep = peerDescriptor
     const entryPoint = createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
@@ -42,8 +41,7 @@ const prepareLayer0 = async () => {
 const prepareStream = async (streamId: string) => {
     console.log('Preparing stream ')
     const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion(),
-        nodeName: streamId
+        region: getRandomRegion()
     })
     const streamPartId = toStreamPartID(toStreamID(streamId), 0)
     const streamPublisher = createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
@@ -61,10 +59,9 @@ const shutdownNetwork = async () => {
     simulator.stop()
 }
 
-const measureJoiningTime = async (count: number) => {
+const measureJoiningTime = async () => {
     const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion(),
-        nodeName: `${count}`
+        region: getRandomRegion()
     })
     console.log('starting node with id ', getNodeIdFromPeerDescriptor(peerDescriptor))
 
@@ -93,7 +90,7 @@ const measureJoiningTime = async (count: number) => {
     }, 1000)
     // get random node from network to use as entrypoint
     const randomNode = nodes[Math.floor(Math.random() * nodes.length)]
-    const streamSubscriber = createNetworkNodeWithSimulator(peerDescriptor, simulator, [randomNode.stack.getLayer0DhtNode().getPeerDescriptor()])
+    const streamSubscriber = createNetworkNodeWithSimulator(peerDescriptor, simulator, [randomNode.stack.getLayer0Node().getPeerDescriptor()])
     currentNode = streamSubscriber
     const start = performance.now()
     await streamSubscriber.start()
@@ -121,7 +118,7 @@ const run = async () => {
     
     fs.writeSync(logFile, 'Network size' + '\t' + 'Time to receive first message time (ms)' + '\n')
     for (let i = 0; i < numNodes; i++) {
-        const time = await measureJoiningTime(i)
+        const time = await measureJoiningTime()
         console.log(`Time to receive first message for ${i + 1} nodes network: ${time}ms`)
         fs.writeSync(logFile, `${i + 1}` + '\t' + `${Math.round(time)}\n`)
     }
@@ -135,14 +132,16 @@ run().then(() => {
     console.log('done')
 }).catch((err) => {
     console.error(err)
-    const streamParts = currentNode.stack.getStreamrNode()!.getStreamParts()
-    const foundData = nodes[0].stack.getLayer0DhtNode().getDataFromDht(streamPartIdToDataKey(streamParts[0]))
+    const streamrNode = currentNode.stack.getStreamrNode()
+    const streamParts = streamrNode.getStreamParts()
+    const foundData = nodes[0].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(streamParts[0]))
     console.log(foundData)
-    console.log(currentNode.stack.getLayer0DhtNode().getKBucketPeers().length)
-    console.log(currentNode.stack.getLayer0DhtNode().getNumberOfConnections())
-    const stream = currentNode.stack.getStreamrNode().getStream(streamParts[0])! as { layer1: ILayer1, node: RandomGraphNode }
-    console.log(stream.layer1.getKBucketPeers())
-    console.log(stream.node.getTargetNeighborIds())
+    const layer0Node = currentNode.stack.getLayer0Node() as DhtNode
+    console.log(layer0Node.getKBucketPeers().length)
+    console.log(layer0Node.getNumberOfConnections())
+    const streamPartDelivery = streamrNode.getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: RandomGraphNode }
+    console.log(streamPartDelivery.layer1Node.getKBucketPeers())
+    console.log(streamPartDelivery.node.getTargetNeighborIds())
     console.log(nodes[nodes.length - 1])
     if (publishInterval) {
         clearInterval(publishInterval)

package/test/end-to-end/inspect.test.ts

@@ -1,9 +1,11 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
 describe('inspect', () => {
 
     const publisherDescriptor = createMockPeerDescriptor({
@@ -30,8 +32,6 @@ describe('inspect', () => {
         }
     })
 
-    const streamPartId = toStreamPartID(toStreamID('stream'), 0)
-
     let publisherNode: NetworkNode
 
     let inspectedNode: NetworkNode
@@ -40,8 +40,8 @@ describe('inspect', () => {
 
     const message = new StreamMessage({ 
         messageId: new MessageID(
-            toStreamID('stream'),
-            0,
+            StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+            StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
             666,
             0,
             randomEthereumAddress(),
@@ -81,14 +81,14 @@ describe('inspect', () => {
         await inspectedNode.start()
         await inspectorNode.start()
 
-        publisherNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
-        inspectedNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
-        inspectorNode.stack.getStreamrNode()!.joinStreamPart(streamPartId)
+        publisherNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        inspectedNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
+        inspectorNode.stack.getStreamrNode()!.joinStreamPart(STREAM_PART_ID)
 
         await waitForCondition(() => 
-            publisherNode.stack.getStreamrNode().getNeighbors(streamPartId).length === 2 
-            && inspectedNode.stack.getStreamrNode().getNeighbors(streamPartId).length === 2 
-            && inspectorNode.stack.getStreamrNode().getNeighbors(streamPartId).length === 2
+            publisherNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2 
+            && inspectedNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2 
+            && inspectorNode.stack.getStreamrNode().getNeighbors(STREAM_PART_ID).length === 2
         )
     }, 30000)
 
@@ -104,7 +104,7 @@ describe('inspect', () => {
         setTimeout(async () => {
             await publisherNode.broadcast(message)
         }, 250)
-        const success = await inspectorNode.inspect(inspectedDescriptor, streamPartId)
+        const success = await inspectorNode.inspect(inspectedDescriptor, STREAM_PART_ID)
         expect(success).toBe(true)
     })
 

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

@@ -29,7 +29,6 @@ const createMessage = (streamPartId: StreamPartID): StreamMessage => {
 describe('proxy and full node', () => {
 
     const proxyNodeDescriptor = createMockPeerDescriptor({
-        nodeName: 'proxyNode',
         websocket: { host: '127.0.0.1', port: 23135, tls: false }
     })
     const proxiedNodeDescriptor = createMockPeerDescriptor()
@@ -72,57 +71,57 @@ describe('proxy and full node', () => {
         await proxiedNode.stop()
     })
 
-    it('proxied node can act as full node on another stream', async () => {
+    it('proxied node can act as full node on another stream part', async () => {
         await proxiedNode.setProxies(proxiedStreamPart, [proxyNodeDescriptor], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
-        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(false)
+        expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(false)
 
         await Promise.all([
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(regularStreamPart1))
         ])
 
-        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(true)
+        expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(true)
 
         await Promise.all([
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
-        expect(proxiedNode.stack.getStreamrNode().getStream(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart1)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
     })
 
-    it('proxied node can act as full node on multiple streams', async () => {
+    it('proxied node can act as full node on multiple stream parts', async () => {
         await proxiedNode.setProxies(proxiedStreamPart, [proxyNodeDescriptor], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
-        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(false)
+        expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(false)
 
         await Promise.all([
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream1'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream2'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream3'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === 'regular-stream4'),
+                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
             proxiedNode.broadcast(createMessage(regularStreamPart1)),
             proxiedNode.broadcast(createMessage(regularStreamPart2)),
             proxiedNode.broadcast(createMessage(regularStreamPart3)),
             proxiedNode.broadcast(createMessage(regularStreamPart4))
         ])
 
-        expect(proxiedNode.stack.getLayer0DhtNode().hasJoined()).toBe(true)
+        expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(true)
 
         await Promise.all([
             waitForEvent3(proxyNode.stack.getStreamrNode()! as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
-        expect(proxiedNode.stack.getStreamrNode().getStream(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart1)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart2)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart3)!.proxied).toBe(false)
-        expect(proxiedNode.stack.getStreamrNode().getStream(regularStreamPart4)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart2)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart3)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart4)!.proxied).toBe(false)
     })
 
 })

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

@@ -1,19 +1,19 @@
-import { MessageID, MessageRef, StreamMessage, StreamMessageType, toStreamID, toStreamPartID } from '@streamr/protocol'
+import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { NodeID } from '../../src/identifiers'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
-import { ProxyStreamConnectionClient } from '../../src/logic/proxy/ProxyStreamConnectionClient'
+import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const PROXIED_NODE_USER_ID = randomEthereumAddress()
-const STREAM_PART_ID = toStreamPartID(toStreamID('proxy-test'), 0)
+const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
 const MESSAGE = new StreamMessage({
     messageId: new MessageID(
-        toStreamID('proxy-test'),
-        0,
+        StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+        StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
         666,
         0,
         randomEthereumAddress(),
@@ -34,24 +34,22 @@ describe('Proxy connections', () => {
     let proxiedNode: NetworkNode
 
     const hasConnectionFromProxy = (proxyNode: NetworkNode): boolean => {
-        const delivery = proxyNode.stack.getStreamrNode()!.getStream(STREAM_PART_ID)
+        const delivery = proxyNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID)
         return (delivery !== undefined)
             ? ((delivery as { node: RandomGraphNode }).node).hasProxyConnection(proxiedNode.getNodeId())
             : false
     }
     
     const hasConnectionToProxy = (proxyNodeId: NodeID, direction: ProxyDirection): boolean => {
-        const client = (proxiedNode.stack.getStreamrNode()!.getStream(STREAM_PART_ID) as { client: ProxyStreamConnectionClient }).client
+        const client = (proxiedNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
         return client.hasConnection(proxyNodeId, direction)
     }
 
     beforeEach(async () => {
         const proxyNodeDescriptor1 = createMockPeerDescriptor({
-            nodeName: 'proxyNode',
             websocket: { host: '127.0.0.1', port: 23132, tls: false }
         })
         const proxyNodeDescriptor2 = createMockPeerDescriptor({
-            nodeName: 'proxyNode',
             websocket: { host: '127.0.0.1', port: 23133, tls: false }
         })
         const proxiedNodeDescriptor = createMockPeerDescriptor()
@@ -191,7 +189,7 @@ describe('Proxy connections', () => {
         expect(hasConnectionFromProxy(proxyNode1)).toBe(true)
     }, 30000)
 
-    it('cannot join on proxy publish streams', async () => {
+    it('can\'t join proxied stream part', async () => {
         await proxiedNode.setProxies(
             STREAM_PART_ID,
             [proxyNode1.getPeerDescriptor()],
@@ -201,7 +199,7 @@ describe('Proxy connections', () => {
         await expect(proxiedNode.join(STREAM_PART_ID)).rejects.toThrow('Cannot join')
     })
 
-    it('connect publish on proxy subscribe streams', async () => {
+    it('can\'t broadcast to subscribe-only proxied stream part', async () => {
         await proxiedNode.setProxies(
             STREAM_PART_ID,
             [proxyNode1.getPeerDescriptor()],

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

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

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

@@ -5,6 +5,8 @@ import { createStreamMessage } from '../utils/utils'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
+import { Layer0Node } from '../../src/logic/Layer0Node'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('random graph with real connections', () => {
 
@@ -14,12 +16,15 @@ describe('random graph with real connections', () => {
         websocket: { host: '127.0.0.1', port: 12221, tls: false }
     }
 
-    const randomGraphId = StreamPartIDUtils.parse('random-graph#0')
-    let epDhtNode: DhtNode
-    let dhtNode1: DhtNode
-    let dhtNode2: DhtNode
-    let dhtNode3: DhtNode
-    let dhtNode4: DhtNode
+    const streamPartId = StreamPartIDUtils.parse('random-graph#0')
+    // Currently the nodes here are practically layer0 nodes acting as layer1 nodes, for the purpose of this test
+    // they are layer1 nodes as the DHT is per stream
+    // TODO refactor the test to use normal layering style (i.e. have separate objects for layer0 and layer1 nodes)
+    let epDhtNode: Layer0Node & Layer1Node
+    let dhtNode1: Layer0Node & Layer1Node
+    let dhtNode2: Layer0Node & Layer1Node
+    let dhtNode3: Layer0Node & Layer1Node
+    let dhtNode4: Layer0Node & Layer1Node
     let randomGraphNode1: RandomGraphNode
     let randomGraphNode2: RandomGraphNode
     let randomGraphNode3: RandomGraphNode
@@ -41,38 +46,38 @@ describe('random graph with real connections', () => {
 
         randomGraphNode1 = createRandomGraphNode(
             {
-                randomGraphId,
-                layer1: epDhtNode,
-                P2PTransport: epDhtNode.getTransport(),
+                streamPartId,
+                layer1Node: epDhtNode,
+                transport: epDhtNode.getTransport(),
                 connectionLocker: epDhtNode.getTransport() as ConnectionManager,
                 ownPeerDescriptor: epPeerDescriptor
             }
         )
         randomGraphNode2 = createRandomGraphNode({
-            randomGraphId,
-            layer1: dhtNode1,
-            P2PTransport: dhtNode1.getTransport(),
+            streamPartId,
+            layer1Node: dhtNode1,
+            transport: dhtNode1.getTransport(),
             connectionLocker: dhtNode1.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode1.getPeerDescriptor()
         })
         randomGraphNode3 = createRandomGraphNode({
-            randomGraphId,
-            layer1: dhtNode2,
-            P2PTransport: dhtNode2.getTransport(),
+            streamPartId,
+            layer1Node: dhtNode2,
+            transport: dhtNode2.getTransport(),
             connectionLocker: dhtNode2.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode2.getPeerDescriptor()
         })
         randomGraphNode4 = createRandomGraphNode({
-            randomGraphId,
-            layer1: dhtNode3,
-            P2PTransport: dhtNode3.getTransport(),
+            streamPartId,
+            layer1Node: dhtNode3,
+            transport: dhtNode3.getTransport(),
             connectionLocker: dhtNode3.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode3.getPeerDescriptor()
         })
         randomGraphNode5 = createRandomGraphNode({
-            randomGraphId,
-            layer1: dhtNode4,
-            P2PTransport: dhtNode4.getTransport(),
+            streamPartId,
+            layer1Node: dhtNode4,
+            transport: dhtNode4.getTransport(),
             connectionLocker: dhtNode4.getTransport() as ConnectionManager,
             ownPeerDescriptor: dhtNode4.getPeerDescriptor()
         })
@@ -144,7 +149,7 @@ describe('random graph with real connections', () => {
 
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            randomGraphId,
+            streamPartId,
             randomEthereumAddress()
         )
         randomGraphNode1.broadcast(msg)

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

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