@streamr/trackerless-network 100.0.0 → 100.1.0

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

@@ -316,9 +316,9 @@ export interface StreamPartitionInfo {
      */
     controlLayerNeighbors: PeerDescriptor[];
     /**
-     * @generated from protobuf field: repeated dht.PeerDescriptor deliveryLayerNeighbors = 3;
+     * @generated from protobuf field: repeated dht.PeerDescriptor contentDeliveryLayerNeighbors = 3;
      */
-    deliveryLayerNeighbors: PeerDescriptor[];
+    contentDeliveryLayerNeighbors: PeerDescriptor[];
 }
 /**
  * @generated from protobuf message ControlLayerInfo
@@ -413,7 +413,11 @@ export enum SignatureType {
     /**
      * @generated from protobuf enum value: SECP256K1 = 1;
      */
-    SECP256K1 = 1
+    SECP256K1 = 1,
+    /**
+     * @generated from protobuf enum value: ERC_1271 = 2;
+     */
+    ERC_1271 = 2
 }
 /**
  * @generated from protobuf enum ProxyDirection
@@ -678,7 +682,7 @@ class StreamPartitionInfo$Type extends MessageType<StreamPartitionInfo> {
         super("StreamPartitionInfo", [
             { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "controlLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
-            { no: 3, name: "deliveryLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }
+            { no: 3, name: "contentDeliveryLayerNeighbors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }
         ]);
     }
 }
@@ -725,9 +729,9 @@ class NodeInfoResponse$Type extends MessageType<NodeInfoResponse> {
  */
 export const NodeInfoResponse = new NodeInfoResponse$Type();
 /**
- * @generated ServiceType for protobuf service DeliveryRpc
+ * @generated ServiceType for protobuf service ContentDeliveryRpc
  */
-export const DeliveryRpc = new ServiceType("DeliveryRpc", [
+export const ContentDeliveryRpc = new ServiceType("ContentDeliveryRpc", [
     { name: "sendStreamMessage", options: {}, I: StreamMessage, O: Empty },
     { name: "leaveStreamPartNotice", options: {}, I: LeaveStreamPartNotice, O: Empty }
 ]);

package/test/benchmark/first-message.ts

@@ -119,7 +119,7 @@ const measureJoiningTime = async () => {
     await streamSubscriber.start()
 
     await Promise.all([
-        waitForEvent3(streamSubscriber.stack.getStreamrNode() as any, 'newMessage', 60000),
+        waitForEvent3(streamSubscriber.stack.getContentDeliveryManager() as any, 'newMessage', 60000),
         streamSubscriber.join(stream)
     ])
 
@@ -153,14 +153,14 @@ run().then(() => {
     console.log('done')
 }).catch((err) => {
     console.error(err)
-    const streamrNode = currentNode.stack.getStreamrNode()
-    const streamParts = streamrNode.getStreamParts()
+    const contentDeliveryManager = currentNode.stack.getContentDeliveryManager()
+    const streamParts = contentDeliveryManager.getStreamParts()
     const foundData = nodes[0].stack.getLayer0Node().fetchDataFromDht(streamPartIdToDataKey(streamParts[0]))
     console.log(foundData)
     const layer0Node = currentNode.stack.getLayer0Node() as DhtNode
     console.log(layer0Node.getNeighbors().length)
     console.log(layer0Node.getConnectionCount())
-    const streamPartDelivery = streamrNode.getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: RandomGraphNode }
+    const streamPartDelivery = contentDeliveryManager.getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: RandomGraphNode }
     console.log(streamPartDelivery.layer1Node.getNeighbors())
     console.log(streamPartDelivery.node.getNeighbors())
     console.log(nodes[nodes.length - 1])

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

@@ -96,14 +96,14 @@ describe('inspect', () => {
         await inspectedNode.start()
         await inspectorNode.start()
 
-        publisherNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
-        inspectedNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
-        inspectorNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        publisherNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
+        inspectedNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
+        inspectorNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
 
         await waitForCondition(() => 
-            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
+            publisherNode.stack.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length === 2 
+            && inspectedNode.stack.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length === 2 
+            && inspectorNode.stack.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length === 2
         )
     }, 30000)
 

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

@@ -65,11 +65,11 @@ describe('proxy and full node', () => {
             }
         })
         await proxyNode.start()
-        proxyNode.stack.getStreamrNode().joinStreamPart(proxiedStreamPart)
-        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart1)
-        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart2)
-        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart3)
-        proxyNode.stack.getStreamrNode().joinStreamPart(regularStreamPart4)
+        proxyNode.stack.getContentDeliveryManager().joinStreamPart(proxiedStreamPart)
+        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart1)
+        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart2)
+        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart3)
+        proxyNode.stack.getContentDeliveryManager().joinStreamPart(regularStreamPart4)
 
         proxiedNode = createNetworkNode({
             layer0: {
@@ -90,19 +90,19 @@ describe('proxy and full node', () => {
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(false)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(regularStreamPart1))
         ])
 
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(true)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
-        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
-        expect(proxiedNode.stack.getStreamrNode().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
     })
 
     it('proxied node can act as full node on multiple stream parts', async () => {
@@ -110,13 +110,13 @@ describe('proxy and full node', () => {
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(false)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage', 5000, 
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
                 (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
             proxiedNode.broadcast(createMessage(regularStreamPart1)),
             proxiedNode.broadcast(createMessage(regularStreamPart2)),
@@ -127,15 +127,15 @@ describe('proxy and full node', () => {
         expect(proxiedNode.stack.getLayer0Node().hasJoined()).toBe(true)
 
         await Promise.all([
-            waitForEvent3(proxyNode.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage'),
             proxiedNode.broadcast(createMessage(proxiedStreamPart))
         ])
 
-        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)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(proxiedStreamPart)!.proxied).toBe(true)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart1)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart2)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart3)!.proxied).toBe(false)
+        expect(proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(regularStreamPart4)!.proxied).toBe(false)
     })
 
 })

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

@@ -46,14 +46,14 @@ describe('Proxy connections', () => {
     let proxiedNode: NetworkNode
 
     const hasConnectionFromProxy = (proxyNode: NetworkNode): boolean => {
-        const delivery = proxyNode.stack.getStreamrNode().getStreamPartDelivery(STREAM_PART_ID)
+        const delivery = proxyNode.stack.getContentDeliveryManager().getStreamPartDelivery(STREAM_PART_ID)
         return (delivery !== undefined)
             ? ((delivery as { node: RandomGraphNode }).node).hasProxyConnection(proxiedNode.getNodeId())
             : false
     }
     
     const hasConnectionToProxy = (proxyNodeId: DhtAddress, direction: ProxyDirection): boolean => {
-        const client = (proxiedNode.stack.getStreamrNode().getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
+        const client = (proxiedNode.stack.getContentDeliveryManager().getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
         return client.hasConnection(proxyNodeId, direction)
     }
 
@@ -77,7 +77,7 @@ describe('Proxy connections', () => {
         })
         await proxyNode1.start()
         proxyNode1.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
-        proxyNode1.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         proxyNode2 = createNetworkNode({
             layer0: {
                 entryPoints: [proxyNodeDescriptor1],
@@ -90,7 +90,7 @@ describe('Proxy connections', () => {
         })
         await proxyNode2.start()
         proxyNode2.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor1])
-        proxyNode2.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        proxyNode2.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         proxiedNode = createNetworkNode({
             layer0: {
                 entryPoints: [proxyNode1.getPeerDescriptor()],
@@ -109,7 +109,7 @@ describe('Proxy connections', () => {
     it('happy path publishing', async () => {
         await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.PUBLISH, PROXIED_NODE_USER_ID, 1)
         await Promise.all([
-            waitForEvent3(proxyNode1.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(proxyNode1.stack.getContentDeliveryManager() as any, 'newMessage'),
             proxiedNode.broadcast(MESSAGE)
         ])
     })
@@ -117,7 +117,7 @@ describe('Proxy connections', () => {
     it('happy path subscribing', async () => {
         await proxiedNode.setProxies(STREAM_PART_ID, [proxyNode1.getPeerDescriptor()], ProxyDirection.SUBSCRIBE, PROXIED_NODE_USER_ID, 1)
         await Promise.all([
-            waitForEvent3(proxiedNode.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(proxiedNode.stack.getContentDeliveryManager() as any, 'newMessage'),
             proxyNode1.broadcast(MESSAGE)
         ])
     })
@@ -196,7 +196,7 @@ describe('Proxy connections', () => {
         await proxyNode1.leave(STREAM_PART_ID)
         await waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE))
         expect(hasConnectionFromProxy(proxyNode1)).toBe(false)
-        proxyNode1.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        proxyNode1.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         await waitForCondition(() => hasConnectionToProxy(proxyNode1.getNodeId(), ProxyDirection.SUBSCRIBE), 25000)
         // TODO why wait is needed?
         await wait(100)

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

@@ -47,7 +47,7 @@ describe('proxy group key exchange', () => {
         })
         await proxyNode.start()
         proxyNode.setStreamPartEntryPoints(STREAM_PART_ID, [proxyNodeDescriptor])
-        proxyNode.stack.getStreamrNode().joinStreamPart(STREAM_PART_ID)
+        proxyNode.stack.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
         publisher = createNetworkNode({
             layer0: {
                 entryPoints: [proxyNodeDescriptor],
@@ -101,7 +101,7 @@ describe('proxy group key exchange', () => {
         })
 
         await Promise.all([
-            waitForEvent3(publisher.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(publisher.stack.getContentDeliveryManager() as any, 'newMessage'),
             subscriber.broadcast(request)
         ])
     })
@@ -133,7 +133,7 @@ describe('proxy group key exchange', () => {
         })
 
         await Promise.all([
-            waitForEvent3(subscriber.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(subscriber.stack.getContentDeliveryManager() as any, 'newMessage'),
             publisher.broadcast(response)
         ])
     })

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

@@ -33,8 +33,8 @@ describe('Full node network with WebRTC connections', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-        entryPoint.getStreamrNode().joinStreamPart(streamPartId)
+        entryPoint.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getContentDeliveryManager().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(streamPartId, [epPeerDescriptor])
-            node.getStreamrNode().joinStreamPart(streamPartId)
+            node.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+            node.getContentDeliveryManager().joinStreamPart(streamPartId)
         }))
 
     }, 90000)
@@ -62,15 +62,15 @@ describe('Full node network with WebRTC connections', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode().getNeighbors(streamPartId).length >= 3
+                return node.getContentDeliveryManager().getNeighbors(streamPartId).length >= 3
             }
             , 30000)
         ))
         let receivedMessageCount = 0
         const successIds: string[] = []
         nodes.forEach((node) => {
-            node.getStreamrNode().on('newMessage', () => {
-                successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode().getPeerDescriptor()))
+            node.getContentDeliveryManager().on('newMessage', () => {
+                successIds.push(getNodeIdFromPeerDescriptor(node.getContentDeliveryManager().getPeerDescriptor()))
                 receivedMessageCount += 1
             })
         })
@@ -79,7 +79,7 @@ describe('Full node network with WebRTC connections', () => {
             streamPartId,
             randomEthereumAddress()
         )
-        entryPoint.getStreamrNode().broadcast(msg)
+        entryPoint.getContentDeliveryManager().broadcast(msg)
         await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
     }, 120000)
 

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

@@ -8,7 +8,7 @@ import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('Full node network with WebSocket connections only', () => {
 
-    const NUM_OF_NODES = 32
+    const NUM_OF_NODES = 20
     const epPeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 15555, tls: false }
     })
@@ -30,8 +30,8 @@ describe('Full node network with WebSocket connections only', () => {
             }
         })
         await entryPoint.start()
-        entryPoint.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-        entryPoint.getStreamrNode().joinStreamPart(streamPartId)
+        entryPoint.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+        entryPoint.getContentDeliveryManager().joinStreamPart(streamPartId)
 
         await Promise.all(range(NUM_OF_NODES).map(async (i) => {
             const node = new NetworkStack({
@@ -44,8 +44,8 @@ describe('Full node network with WebSocket connections only', () => {
             })
             nodes.push(node)
             await node.start()
-            node.getStreamrNode().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
-            node.getStreamrNode().joinStreamPart(streamPartId)
+            node.getContentDeliveryManager().setStreamPartEntryPoints(streamPartId, [epPeerDescriptor])
+            node.getContentDeliveryManager().joinStreamPart(streamPartId)
         }))
 
     }, 120000)
@@ -60,15 +60,15 @@ describe('Full node network with WebSocket connections only', () => {
     it('happy path', async () => {
         await Promise.all(nodes.map((node) =>
             waitForCondition(() => {
-                return node.getStreamrNode().getNeighbors(streamPartId).length >= 4
+                return node.getContentDeliveryManager().getNeighbors(streamPartId).length >= 4
             }
             , 30000)
         ))
         let receivedMessageCount = 0
         const successIds: string[] = []
         nodes.forEach((node) => {
-            node.getStreamrNode().on('newMessage', () => {
-                successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode().getPeerDescriptor()))
+            node.getContentDeliveryManager().on('newMessage', () => {
+                successIds.push(getNodeIdFromPeerDescriptor(node.getContentDeliveryManager().getPeerDescriptor()))
                 receivedMessageCount += 1
             })
         })
@@ -78,7 +78,7 @@ describe('Full node network with WebSocket connections only', () => {
             streamPartId,
             randomEthereumAddress()
         )
-        entryPoint.getStreamrNode().broadcast(msg)
+        entryPoint.getContentDeliveryManager().broadcast(msg)
         await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
     }, 220000)
 

package/test/integration/ContentDeliveryManager.test.ts

@@ -0,0 +1,135 @@
+import {
+    DhtNode,
+    Simulator,
+    SimulatorTransport
+} from '@streamr/dht'
+import { ContentDeliveryManager, Events } from '../../src/logic/ContentDeliveryManager'
+import { waitForEvent3, waitForCondition } from '@streamr/utils'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { randomEthereumAddress } from '@streamr/test-utils'
+import { Layer0Node } from '../../src/logic/Layer0Node'
+
+describe('ContentDeliveryManager', () => {
+
+    let layer0Node1: Layer0Node
+    let layer0Node2: Layer0Node
+    let transport1: SimulatorTransport
+    let transport2: SimulatorTransport
+    let manager1: ContentDeliveryManager
+    let manager2: ContentDeliveryManager
+
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
+    const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
+
+    const msg = createStreamMessage(
+        JSON.stringify({ hello: 'WORLD' }),
+        STREAM_PART_ID,
+        randomEthereumAddress()
+    )
+
+    afterEach(async () => {
+        await Promise.all([
+            manager1.destroy(),
+            manager2.destroy()
+        ])
+    })
+
+    beforeEach(async () => {
+        const simulator = new Simulator()
+        transport1 = new SimulatorTransport(peerDescriptor1, simulator)
+        await transport1.start()
+        transport2 = new SimulatorTransport(peerDescriptor2, simulator)
+        await transport2.start()
+        layer0Node1 = new DhtNode({
+            transport: transport1,
+            peerDescriptor: peerDescriptor1,
+            entryPoints: [peerDescriptor1]
+        })
+        layer0Node2 = new DhtNode({
+            transport: transport2,
+            peerDescriptor: peerDescriptor2,
+            entryPoints: [peerDescriptor1]
+        })
+        await Promise.all([
+            layer0Node1.start(),
+            layer0Node2.start()
+        ])
+        await Promise.all([
+            layer0Node1.joinDht([peerDescriptor1]),
+            layer0Node2.joinDht([peerDescriptor1])
+        ])
+
+        manager1 = new ContentDeliveryManager({})
+        manager2 = new ContentDeliveryManager({})
+        await manager1.start(layer0Node1, transport1, transport1)
+        manager1.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
+        await manager2.start(layer0Node2, transport2, transport2)
+        manager2.setStreamPartEntryPoints(STREAM_PART_ID, [peerDescriptor1])
+    })
+
+    it('starts', async () => {
+        expect(manager1.getPeerDescriptor()).toEqual(peerDescriptor1)
+        expect(manager2.getPeerDescriptor()).toEqual(peerDescriptor2)
+    })
+
+    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)
+        expect(manager1.getNeighbors(STREAM_PART_ID).length).toEqual(1)
+        expect(manager2.getNeighbors(STREAM_PART_ID).length).toEqual(1)
+    })
+
+    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 Promise.all([
+            waitForEvent3<Events>(manager1, 'newMessage'),
+            manager2.broadcast(msg)
+        ])
+    })
+
+    it('multi-stream pub/sub', async () => {
+        const streamPartId2 = StreamPartIDUtils.parse('test2#0')
+        manager1.setStreamPartEntryPoints(streamPartId2, [peerDescriptor1])
+        manager2.setStreamPartEntryPoints(streamPartId2, [peerDescriptor1])
+        manager1.joinStreamPart(STREAM_PART_ID)
+        manager1.joinStreamPart(streamPartId2)
+        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)
+        ])
+        const msg2 = createStreamMessage(
+            JSON.stringify({ hello: 'WORLD' }),
+            streamPartId2,
+            randomEthereumAddress()
+        )
+        await Promise.all([
+            waitForEvent3<Events>(manager1, 'newMessage'),
+            waitForEvent3<Events>(manager2, 'newMessage'),
+            manager1.broadcast(msg2),
+            manager2.broadcast(msg)
+        ])
+    })
+
+    it('leaving stream parts', 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)
+        ])
+        await manager2.leaveStreamPart(STREAM_PART_ID)
+        await waitForCondition(() => manager1.getNeighbors(STREAM_PART_ID).length === 0)
+    })
+
+})

package/test/integration/{DeliveryRpcRemote.test.ts → ContentDeliveryRpcRemote.test.ts}

@@ -5,8 +5,8 @@ import {
     SimulatorTransport,
     NodeType
 } from '@streamr/dht'
-import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
+import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
     LeaveStreamPartNotice,
     StreamMessage
@@ -17,10 +17,10 @@ import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-describe('DeliveryRpcRemote', () => {
+describe('ContentDeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
-    let rpcRemote: DeliveryRpcRemote
+    let rpcRemote: ContentDeliveryRpcRemote
 
     const clientNode: PeerDescriptor = {
         nodeId: new Uint8Array([1, 1, 1]),
@@ -66,11 +66,11 @@ describe('DeliveryRpcRemote', () => {
             }
         )
 
-        rpcRemote = new DeliveryRpcRemote(
+        rpcRemote = new ContentDeliveryRpcRemote(
             clientNode,
             serverNode,
             clientRpc,
-            DeliveryRpcClient
+            ContentDeliveryRpcClient
         )
     })
 

package/test/integration/Inspect.test.ts

@@ -75,12 +75,12 @@ describe('inspect', () => {
                 123123,
                 sequenceNumber
             )
-            publisherNode.getStreamrNode().broadcast(msg)
+            publisherNode.getContentDeliveryManager().broadcast(msg)
             sequenceNumber += 1
         }, 200)
 
         for (const node of inspectedNodes) {
-            const result = await inspectorNode.getStreamrNode().inspect(node.getLayer0Node().getLocalPeerDescriptor(), streamPartId)
+            const result = await inspectorNode.getContentDeliveryManager().inspect(node.getLayer0Node().getLocalPeerDescriptor(), streamPartId)
             expect(result).toEqual(true)
         }
     }, 25000)

package/test/integration/NetworkRpc.test.ts

@@ -3,7 +3,7 @@ import {
     ProtoRpcClient,
     toProtoRpcClient
 } from '@streamr/proto-rpc'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
@@ -16,7 +16,7 @@ import { randomEthereumAddress } from '@streamr/test-utils'
 describe('Network RPC', () => {
     let rpcCommunicator1: RpcCommunicator<DhtCallContext>
     let rpcCommunicator2: RpcCommunicator<DhtCallContext>
-    let client: ProtoRpcClient<DeliveryRpcClient>
+    let client: ProtoRpcClient<ContentDeliveryRpcClient>
     let recvCounter = 0
 
     beforeEach(() => {
@@ -25,7 +25,7 @@ describe('Network RPC', () => {
         rpcCommunicator1.on('outgoingMessage', (message: RpcMessage) => {
             rpcCommunicator2.handleIncomingMessage(message)
         })
-        client = toProtoRpcClient(new DeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
+        client = toProtoRpcClient(new ContentDeliveryRpcClient(rpcCommunicator1.getRpcClientTransport()))
         rpcCommunicator2.registerRpcNotification(
             StreamMessage,
             'sendStreamMessage',

package/test/integration/NetworkStack.test.ts

@@ -34,9 +34,9 @@ describe('NetworkStack', () => {
         })
 
         await stack1.start()
-        stack1.getStreamrNode().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
+        stack1.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
         await stack2.start()
-        stack2.getStreamrNode().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
+        stack2.getContentDeliveryManager().setStreamPartEntryPoints(STREAM_PART_ID, [epDescriptor])
     })
 
     afterEach(async () => {
@@ -48,8 +48,8 @@ describe('NetworkStack', () => {
 
     it('Can use NetworkNode pub/sub via NetworkStack', async () => {
         let receivedMessages = 0
-        stack1.getStreamrNode().joinStreamPart(STREAM_PART_ID)
-        stack1.getStreamrNode().on('newMessage', () => {
+        stack1.getContentDeliveryManager().joinStreamPart(STREAM_PART_ID)
+        stack1.getContentDeliveryManager().on('newMessage', () => {
             receivedMessages += 1
         })
         const msg = createStreamMessage(
@@ -57,7 +57,7 @@ describe('NetworkStack', () => {
             STREAM_PART_ID,
             randomEthereumAddress()
         )
-        stack2.getStreamrNode().broadcast(msg)
+        stack2.getContentDeliveryManager().broadcast(msg)
         await waitForCondition(() => receivedMessages === 1)
     })
 
@@ -66,7 +66,7 @@ describe('NetworkStack', () => {
             stack1.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
             stack2.joinStreamPart(STREAM_PART_ID, { minCount: 1, timeout: 5000 }),
         ])
-        expect(stack1.getStreamrNode().getNeighbors(STREAM_PART_ID).length).toBe(1)
-        expect(stack2.getStreamrNode().getNeighbors(STREAM_PART_ID).length).toBe(1)
+        expect(stack1.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
+        expect(stack2.getContentDeliveryManager().getNeighbors(STREAM_PART_ID).length).toBe(1)
     })
 })