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

package/test/integration/Propagation.test.ts

@@ -1,14 +1,15 @@
-import { DhtNode, Simulator } from '@streamr/dht'
+import { Simulator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createMockPeerDescriptor, createMockRandomGraphNodeAndDhtNode, createStreamMessage } from '../utils/utils'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('Propagation', () => {
     const entryPointDescriptor = createMockPeerDescriptor()
-    let dhtNodes: DhtNode[]
+    let layer1Nodes: Layer1Node[]
     let randomGraphNodes: RandomGraphNode[]
     const STREAM_PART_ID = StreamPartIDUtils.parse('testingtesting#0')
     let totalReceived: number
@@ -17,38 +18,38 @@ describe('Propagation', () => {
     beforeEach(async () => {
         totalReceived = 0
         const simulator = new Simulator()
-        dhtNodes = []
+        layer1Nodes = []
         randomGraphNodes = []
-        const [entryPoint, node1] = createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_PART_ID, simulator)
+        const [entryPoint, node1] = await createMockRandomGraphNodeAndDhtNode(entryPointDescriptor, entryPointDescriptor, STREAM_PART_ID, simulator)
         await entryPoint.start()
         await entryPoint.joinDht([entryPointDescriptor])
         await node1.start()
         node1.on('message', () => {totalReceived += 1})
-        dhtNodes.push(entryPoint)
+        layer1Nodes.push(entryPoint)
         randomGraphNodes.push(node1)
 
         await Promise.all(range(NUM_OF_NODES).map(async (_i) => {
             const descriptor = createMockPeerDescriptor()
-            const [dht, graph] = createMockRandomGraphNodeAndDhtNode(
+            const [layer1, randomGraphNode] = await createMockRandomGraphNodeAndDhtNode(
                 descriptor,
                 entryPointDescriptor,
                 STREAM_PART_ID,
                 simulator
             )
-            await dht.start()
-            await graph.start()
+            await layer1.start()
+            await randomGraphNode.start()
             // eslint-disable-next-line promise/always-return
-            await dht.joinDht([entryPointDescriptor]).then(() => {
-                graph.on('message', () => { totalReceived += 1 })
-                dhtNodes.push(dht)
-                randomGraphNodes.push(graph)
+            await layer1.joinDht([entryPointDescriptor]).then(() => {
+                randomGraphNode.on('message', () => { totalReceived += 1 })
+                layer1Nodes.push(layer1)
+                randomGraphNodes.push(randomGraphNode)
             })
         }))
     }, 45000)
 
     afterEach(async () => {
         await Promise.all(randomGraphNodes.map((node) => node.stop()))
-        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(layer1Nodes.map((node) => node.stop()))
     })
 
     it('All nodes receive messages', async () => {

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

@@ -5,11 +5,12 @@ import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('RandomGraphNode-DhtNode-Latencies', () => {
     const numOfNodes = 64
-    let dhtNodes: DhtNode[]
-    let dhtEntryPoint: DhtNode
+    let layer1Nodes: Layer1Node[]
+    let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
     let graphNodes: RandomGraphNode[]
 
@@ -24,47 +25,49 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         const cms: SimulatorTransport[] = range(numOfNodes).map((i) =>
             new SimulatorTransport(peerDescriptors[i], simulator)
         )
+        await entrypointCm.start()
+        await Promise.all(cms.map((cm) => cm.start()))
 
         dhtEntryPoint = new DhtNode({
-            transportLayer: entrypointCm,
+            transport: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
-        dhtNodes = range(numOfNodes).map((i) => new DhtNode({
-            transportLayer: cms[i],
+        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
+            transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
         graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
-            randomGraphId: streamPartId,
-            layer1: dhtNodes[i],
-            P2PTransport: cms[i],
+            streamPartId,
+            layer1Node: layer1Nodes[i],
+            transport: cms[i],
             connectionLocker: cms[i],
             ownPeerDescriptor: peerDescriptors[i]
         }))
         entryPointRandomGraphNode = createRandomGraphNode({
-            randomGraphId: streamPartId,
-            layer1: dhtEntryPoint,
-            P2PTransport: entrypointCm,
+            streamPartId,
+            layer1Node: dhtEntryPoint,
+            transport: entrypointCm,
             connectionLocker: entrypointCm,
             ownPeerDescriptor: entrypointDescriptor
         })
 
         await dhtEntryPoint.start()
         await dhtEntryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(dhtNodes.map((node) => node.start()))
+        await Promise.all(layer1Nodes.map((node) => node.start()))
     })
 
     afterEach(async () => {
         dhtEntryPoint.stop()
         entryPointRandomGraphNode.stop()
-        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
         Simulator.useFakeTimers(false)
     })
 
     it('happy path single node', async () => {
-        await dhtNodes[0].joinDht([entrypointDescriptor])
+        await layer1Nodes[0].joinDht([entrypointDescriptor])
         entryPointRandomGraphNode.start()
         await graphNodes[0].start()
         await Promise.all([
@@ -77,23 +80,23 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
 
     it('happy path 5 nodes', async () => {
         entryPointRandomGraphNode.start()
-        range(4).map((i) => graphNodes[i].start())
+        range(4).forEach((i) => graphNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
-            await dhtNodes[i].joinDht([entrypointDescriptor])
+            await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(range(4).map((i) => {
             return waitForCondition(() => {
                 return graphNodes[i].getTargetNeighborIds().length >= 4
-            }, 10000, 2000)
+            }, 15000, 2000)
         }))
-        range(4).map((i) => {
+        range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
             expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
         })
         // Check bidirectionality
         const allNodes = graphNodes
         allNodes.push(entryPointRandomGraphNode)
-        range(5).map((i) => {
+        range(5).forEach((i) => {
             const ownNodeId = allNodes[i].getOwnNodeId()
             allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
                 const neighbor = allNodes.find((node) => {
@@ -107,7 +110,7 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
     it('happy path 64 nodes', async () => {
         await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
         await Promise.all(range(numOfNodes).map((i) => {
-            dhtNodes[i].joinDht([entrypointDescriptor])
+            layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
             waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)

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

@@ -1,29 +1,28 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, getRandomRegion } from '@streamr/dht'
+import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
 import { Logger, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
+import { Layer1Node } from '../../src/logic/Layer1Node'
 
 const logger = new Logger(module)
 
 describe('RandomGraphNode-DhtNode', () => {
     const numOfNodes = 64
-    let dhtNodes: DhtNode[]
-    let dhtEntryPoint: DhtNode
+    let layer1Nodes: Layer1Node[]
+    let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
     let graphNodes: RandomGraphNode[]
 
     const streamPartId = StreamPartIDUtils.parse('stream#0')
     const entrypointDescriptor = createMockPeerDescriptor({
-        nodeName: 'entrypoint',
         region: getRandomRegion()
     })
 
-    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map((i) => {
+    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => {
         return createMockPeerDescriptor({
-            nodeName: `node${i}`,
             region: getRandomRegion()
         })
     })
@@ -31,43 +30,45 @@ describe('RandomGraphNode-DhtNode', () => {
 
         Simulator.useFakeTimers()
         const simulator = new Simulator()
-        const entrypointCm = new ConnectionManager({
-            ownPeerDescriptor: entrypointDescriptor,
+        const entrypointCm = new SimulatorTransport(
+            entrypointDescriptor,
             simulator
-        })
+        )
+        await entrypointCm.start()
 
         const cms: ConnectionManager[] = range(numOfNodes).map((i) =>
-            new ConnectionManager({
-                ownPeerDescriptor: peerDescriptors[i],
+            new SimulatorTransport(
+                peerDescriptors[i],
                 simulator
-            })
+            )
         )
+        await Promise.all(cms.map((cm) => cm.start()))
 
         dhtEntryPoint = new DhtNode({
-            transportLayer: entrypointCm,
+            transport: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
 
-        dhtNodes = range(numOfNodes).map((i) => new DhtNode({
-            transportLayer: cms[i],
+        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
+            transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
 
         graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
-            randomGraphId: streamPartId,
-            layer1: dhtNodes[i],
-            P2PTransport: cms[i],
+            streamPartId,
+            layer1Node: layer1Nodes[i],
+            transport: cms[i],
             connectionLocker: cms[i],
             ownPeerDescriptor: peerDescriptors[i],
             neighborUpdateInterval: 2000
         }))
 
         entryPointRandomGraphNode = createRandomGraphNode({
-            randomGraphId: streamPartId,
-            layer1: dhtEntryPoint,
-            P2PTransport: entrypointCm,
+            streamPartId,
+            layer1Node: dhtEntryPoint,
+            transport: entrypointCm,
             connectionLocker: entrypointCm,
             ownPeerDescriptor: entrypointDescriptor,
             neighborUpdateInterval: 2000
@@ -75,20 +76,20 @@ describe('RandomGraphNode-DhtNode', () => {
 
         await dhtEntryPoint.start()
         await dhtEntryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(dhtNodes.map((node) => node.start()))
+        await Promise.all(layer1Nodes.map((node) => node.start()))
     })
 
     afterEach(async () => {
         await dhtEntryPoint.stop()
         entryPointRandomGraphNode.stop()
-        await Promise.all(dhtNodes.map((node) => node.stop()))
+        await Promise.all(layer1Nodes.map((node) => node.stop()))
         await Promise.all(graphNodes.map((node) => node.stop()))
         Simulator.useFakeTimers(false)
     })
 
     it('happy path single node ', async () => {
         await entryPointRandomGraphNode.start()
-        await dhtNodes[0].joinDht([entrypointDescriptor])
+        await layer1Nodes[0].joinDht([entrypointDescriptor])
 
         await graphNodes[0].start()
 
@@ -99,13 +100,13 @@ describe('RandomGraphNode-DhtNode', () => {
 
     it('happy path 4 nodes', async () => {
         entryPointRandomGraphNode.start()
-        range(4).map((i) => graphNodes[i].start())
+        range(4).forEach((i) => graphNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
-            await dhtNodes[i].joinDht([entrypointDescriptor])
+            await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
 
         await waitForCondition(() => range(4).every((i) => graphNodes[i].getTargetNeighborIds().length === 4))
-        range(4).map((i) => {
+        range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
             expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
         })
@@ -113,7 +114,7 @@ describe('RandomGraphNode-DhtNode', () => {
         // Check bidirectionality
         const allNodes = graphNodes
         allNodes.push(entryPointRandomGraphNode)
-        range(5).map((i) => {
+        range(5).forEach((i) => {
             allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === nodeId
@@ -126,7 +127,7 @@ describe('RandomGraphNode-DhtNode', () => {
     it('happy path 64 nodes', async () => {
         await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
         await Promise.all(range(numOfNodes).map((i) => {
-            dhtNodes[i].joinDht([entrypointDescriptor])
+            layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
             waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)

package/test/integration/StreamrNode.test.ts

@@ -10,11 +10,12 @@ import { waitForEvent3, waitForCondition } from '@streamr/utils'
 import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
+import { Layer0Node } from '../../src/logic/Layer0Node'
 
 describe('StreamrNode', () => {
 
-    let layer01: DhtNode
-    let layer02: DhtNode
+    let layer0Node1: Layer0Node
+    let layer0Node2: Layer0Node
     let transport1: SimulatorTransport
     let transport2: SimulatorTransport
     let node1: StreamrNode
@@ -46,31 +47,33 @@ describe('StreamrNode', () => {
     beforeEach(async () => {
         const simulator = new Simulator()
         transport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await transport1.start()
         transport2 = new SimulatorTransport(peerDescriptor2, simulator)
-        layer01 = new DhtNode({
-            transportLayer: transport1,
+        await transport2.start()
+        layer0Node1 = new DhtNode({
+            transport: transport1,
             peerDescriptor: peerDescriptor1,
             entryPoints: [peerDescriptor1]
         })
-        layer02 = new DhtNode({
-            transportLayer: transport2,
+        layer0Node2 = new DhtNode({
+            transport: transport2,
             peerDescriptor: peerDescriptor2,
             entryPoints: [peerDescriptor1]
         })
         await Promise.all([
-            layer01.start(),
-            layer02.start()
+            layer0Node1.start(),
+            layer0Node2.start()
         ])
         await Promise.all([
-            layer01.joinDht([peerDescriptor1]),
-            layer02.joinDht([peerDescriptor1])
+            layer0Node1.joinDht([peerDescriptor1]),
+            layer0Node2.joinDht([peerDescriptor1])
         ])
 
         node1 = new StreamrNode({})
         node2 = new StreamrNode({})
-        await node1.start(layer01, transport1, transport1)
+        await node1.start(layer0Node1, transport1, transport1)
         node1.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
-        await node2.start(layer02, transport2, transport2)
+        await node2.start(layer0Node2, transport2, transport2)
         node2.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
     })
 
@@ -126,7 +129,7 @@ describe('StreamrNode', () => {
         ])
     })
 
-    it('leaving streams', async () => {
+    it('leaving stream parts', async () => {
         node1.joinStreamPart(STREAM_PART_ID)
         node2.joinStreamPart(STREAM_PART_ID)
         await Promise.all([

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

@@ -1,42 +1,38 @@
 import { NodeType, PeerDescriptor, Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
 import { NetworkStack } from '../../src/NetworkStack'
-import { streamPartIdToDataKey } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { createStreamMessage } from '../utils/utils'
 import { waitForCondition } from '@streamr/utils'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-describe('Joining streams on offline nodes', () => {
-    const streamPartId = StreamPartIDUtils.parse('stream#0')
+const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')
+
+describe('Joining stream parts on offline nodes', () => {
 
     const entryPointPeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        nodeName: 'entrypoint',
         type: NodeType.NODEJS
     }
 
     const node1PeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 1, 1]),
-        nodeName: 'node1',
         type: NodeType.NODEJS
     }
 
     const node2PeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([2, 2, 2]),
-        nodeName: 'node2',
         type: NodeType.NODEJS
     }
 
     const offlineDescriptor1: PeerDescriptor = {
         kademliaId: new Uint8Array([3, 3, 3]),
-        nodeName: 'offline',
         type: NodeType.NODEJS
     }
 
     const offlineDescriptor2: PeerDescriptor = {
         kademliaId: new Uint8Array([4, 4, 4]),
-        nodeName: 'offline',
         type: NodeType.NODEJS
     }
 
@@ -50,28 +46,30 @@ describe('Joining streams on offline nodes', () => {
         const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
         entryPoint = new NetworkStack({
             layer0: {
-                transportLayer: entryPointTransport,
+                transport: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
-
+        const node1Transport = new SimulatorTransport(node1PeerDescriptor, simulator)
         node1 = new NetworkStack({
             layer0: {
-                transportLayer: new SimulatorTransport(node1PeerDescriptor, simulator),
+                transport: node1Transport,
                 peerDescriptor: node1PeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
-
+        const node2Transport = new SimulatorTransport(node2PeerDescriptor, simulator)
         node2 = new NetworkStack({
             layer0: {
-                transportLayer: new SimulatorTransport(node2PeerDescriptor, simulator),
+                transport: node2Transport,
                 peerDescriptor: node2PeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
-
+        await entryPointTransport.start()
+        await node1Transport.start()
+        await node2Transport.start()
         await entryPoint.start()
         await node1.start()
         await node2.start()
@@ -88,12 +86,12 @@ describe('Joining streams on offline nodes', () => {
         let messageReceived = false
 
         // store offline peer descriptors to DHT
-        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(streamPartId), Any.pack(offlineDescriptor1, PeerDescriptor))
-        await entryPoint.getLayer0DhtNode().storeDataToDht(streamPartIdToDataKey(streamPartId), Any.pack(offlineDescriptor2, PeerDescriptor))
+        await entryPoint.getLayer0Node().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor1, PeerDescriptor))
+        await entryPoint.getLayer0Node().storeDataToDht(streamPartIdToDataKey(STREAM_PART_ID), Any.pack(offlineDescriptor2, PeerDescriptor))
         
-        node1.getStreamrNode().joinStreamPart(streamPartId)
+        node1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
         node1.getStreamrNode().on('newMessage', () => { messageReceived = true })
-        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), streamPartId, randomEthereumAddress())
+        const msg = createStreamMessage(JSON.stringify({ hello: 'WORLD' }), STREAM_PART_ID, randomEthereumAddress())
         node2.getStreamrNode().broadcast(msg)
         await waitForCondition(() => messageReceived, 40000)
     }, 60000)

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

@@ -4,13 +4,12 @@ import {
     MessageRef,
     StreamMessage,
     StreamMessageType,
-    StreamPartIDUtils,
-    toStreamID
+    StreamPartIDUtils
 } from '@streamr/protocol'
 import { EthereumAddress, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { streamPartIdToDataKey } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
@@ -22,14 +21,13 @@ describe('stream without default entrypoints', () => {
     let numOfReceivedMessages: number
     const entryPointPeerDescriptor: PeerDescriptor = {
         kademliaId: new Uint8Array([1, 2, 3]),
-        nodeName: 'entrypoint',
         type: NodeType.NODEJS
     }
 
     const streamMessage = new StreamMessage({
         messageId: new MessageID(
-            toStreamID('test'),
-            0,
+            StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+            StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
             666,
             0,
             '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as EthereumAddress,
@@ -49,23 +47,23 @@ describe('stream without default entrypoints', () => {
         nodes = []
         numOfReceivedMessages = 0
         const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
+        await entryPointTransport.start()
         entrypoint = createNetworkNode({
             layer0: {
-                transportLayer: entryPointTransport,
+                transport: entryPointTransport,
                 peerDescriptor: entryPointPeerDescriptor,
                 entryPoints: [entryPointPeerDescriptor]
             }
         })
         await entrypoint.start()
-        await Promise.all(range(20).map(async (i) => {
-            const peerDescriptor = createMockPeerDescriptor({
-                nodeName: `${i}`
-            })
+        await Promise.all(range(20).map(async () => {
+            const peerDescriptor = createMockPeerDescriptor()
             const transport = new SimulatorTransport(peerDescriptor, simulator)
+            await transport.start()
             const node = createNetworkNode({
                 layer0: {
                     peerDescriptor,
-                    transportLayer: transport,
+                    transport,
                     entryPoints: [entryPointPeerDescriptor]
                 }
             })
@@ -121,8 +119,8 @@ describe('stream without default entrypoints', () => {
             await nodes[i].join(STREAM_PART_ID, { minCount: (i > 0) ? 1 : 0, timeout: 15000 })
         }
         await waitForCondition(async () => {
-            const entryPointData = await nodes[15].stack.getLayer0DhtNode().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
-            return entryPointData.dataEntries!.length >= 7
+            const entryPointData = await nodes[15].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(STREAM_PART_ID))
+            return entryPointData.length >= 7
         }, 15000)
         
     }, 90000)

package/test/unit/{StreamNodeServer.test.ts → DeliveryRpcLocal.test.ts}

@@ -1,14 +1,14 @@
 import { ListeningRpcCommunicator } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { StreamNodeServer } from '../../src/logic/StreamNodeServer'
+import { DeliveryRpcLocal } from '../../src/logic/DeliveryRpcLocal'
 import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
-describe('StreamNodeServer', () => {
+describe('DeliveryRpcLocal', () => {
 
-    let streamNodeServer: StreamNodeServer
+    let rpcLocal: DeliveryRpcLocal
     const peerDescriptor = createMockPeerDescriptor()
 
     const mockSender = createMockPeerDescriptor()
@@ -30,19 +30,19 @@ describe('StreamNodeServer', () => {
         mockOnLeaveNotice = jest.fn((_m) => {})
         mockMarkForInspection = jest.fn((_m) => {})
 
-        streamNodeServer = new StreamNodeServer({
+        rpcLocal = new DeliveryRpcLocal({
             markAndCheckDuplicate: mockDuplicateCheck,
             broadcast: mockBroadcast,
             onLeaveNotice: mockOnLeaveNotice,
             markForInspection: mockMarkForInspection,
             ownPeerDescriptor: peerDescriptor,
-            randomGraphId: 'random-graph',
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
             rpcCommunicator: new ListeningRpcCommunicator('random-graph-node', new MockTransport())
         })
     })
     
     it('Server sendStreamMessage()', async () => {
-        await streamNodeServer.sendStreamMessage(message, { incomingSourceDescriptor: mockSender } as any)
+        await rpcLocal.sendStreamMessage(message, { incomingSourceDescriptor: mockSender } as any)
         expect(mockDuplicateCheck).toHaveBeenCalledTimes(1)
         expect(mockBroadcast).toHaveBeenCalledTimes(1)
         expect(mockMarkForInspection).toHaveBeenCalledTimes(1)
@@ -50,9 +50,9 @@ describe('StreamNodeServer', () => {
 
     it('Server leaveStreamPartNotice()', async () => {
         const leaveNotice: LeaveStreamPartNotice = {
-            randomGraphId: 'random-graph'
+            streamPartId: StreamPartIDUtils.parse('stream#0')
         }
-        await streamNodeServer.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
+        await rpcLocal.leaveStreamPartNotice(leaveNotice, { incomingSourceDescriptor: mockSender } as any)
         expect(mockOnLeaveNotice).toHaveBeenCalledTimes(1)
     })