@streamr/trackerless-network 100.0.0-testnet-three.6 → 100.1.0

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

@@ -52,45 +52,70 @@ export interface MessageRef {
  */
 export interface StreamMessage {
     /**
-     * @generated from protobuf field: StreamMessageType messageType = 1;
-     */
-    messageType: StreamMessageType;
-    /**
-     * @generated from protobuf field: ContentType contentType = 2;
+     * this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
+     *
+     * @generated from protobuf field: MessageID messageId = 1;
      */
-    contentType: ContentType;
+    messageId?: MessageID;
     /**
-     * @generated from protobuf field: EncryptionType encryptionType = 3;
+     * @generated from protobuf field: optional MessageRef previousMessageRef = 2;
      */
-    encryptionType: EncryptionType;
+    previousMessageRef?: MessageRef;
     /**
-     * @generated from protobuf field: bytes content = 4;
+     * @generated from protobuf field: bytes signature = 3;
      */
-    content: Uint8Array;
+    signature: Uint8Array;
     /**
-     * @generated from protobuf field: SignatureType signatureType = 5;
+     * @generated from protobuf field: SignatureType signatureType = 4;
      */
     signatureType: SignatureType;
     /**
-     * @generated from protobuf field: bytes signature = 6;
+     * @generated from protobuf oneof: body
+     */
+    body: {
+        oneofKind: "contentMessage";
+        /**
+         * @generated from protobuf field: ContentMessage contentMessage = 5;
+         */
+        contentMessage: ContentMessage;
+    } | {
+        oneofKind: "groupKeyRequest";
+        /**
+         * @generated from protobuf field: GroupKeyRequest groupKeyRequest = 6;
+         */
+        groupKeyRequest: GroupKeyRequest;
+    } | {
+        oneofKind: "groupKeyResponse";
+        /**
+         * @generated from protobuf field: GroupKeyResponse groupKeyResponse = 7;
+         */
+        groupKeyResponse: GroupKeyResponse;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message ContentMessage
+ */
+export interface ContentMessage {
+    /**
+     * @generated from protobuf field: bytes content = 1;
      */
-    signature: Uint8Array;
+    content: Uint8Array;
     /**
-     * this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
-     *
-     * @generated from protobuf field: MessageID messageId = 7;
+     * @generated from protobuf field: ContentType contentType = 2;
      */
-    messageId?: MessageID;
+    contentType: ContentType;
     /**
-     * @generated from protobuf field: optional MessageRef previousMessageRef = 8;
+     * @generated from protobuf field: EncryptionType encryptionType = 3;
      */
-    previousMessageRef?: MessageRef;
+    encryptionType: EncryptionType;
     /**
-     * @generated from protobuf field: optional string groupKeyId = 9;
+     * @generated from protobuf field: optional string groupKeyId = 4;
      */
     groupKeyId?: string;
     /**
-     * @generated from protobuf field: optional GroupKey newGroupKey = 10;
+     * @generated from protobuf field: optional GroupKey newGroupKey = 5;
      */
     newGroupKey?: GroupKey;
 }
@@ -291,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
@@ -388,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
@@ -437,16 +466,13 @@ export const MessageRef = new MessageRef$Type();
 class StreamMessage$Type extends MessageType<StreamMessage> {
     constructor() {
         super("StreamMessage", [
-            { no: 1, name: "messageType", kind: "enum", T: () => ["StreamMessageType", StreamMessageType] },
-            { no: 2, name: "contentType", kind: "enum", T: () => ["ContentType", ContentType] },
-            { no: 3, name: "encryptionType", kind: "enum", T: () => ["EncryptionType", EncryptionType] },
-            { no: 4, name: "content", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
-            { no: 5, name: "signatureType", kind: "enum", T: () => ["SignatureType", SignatureType] },
-            { no: 6, name: "signature", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
-            { no: 7, name: "messageId", kind: "message", T: () => MessageID },
-            { no: 8, name: "previousMessageRef", kind: "message", T: () => MessageRef },
-            { no: 9, name: "groupKeyId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
-            { no: 10, name: "newGroupKey", kind: "message", T: () => GroupKey }
+            { no: 1, name: "messageId", kind: "message", T: () => MessageID },
+            { no: 2, name: "previousMessageRef", kind: "message", T: () => MessageRef },
+            { no: 3, name: "signature", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 4, name: "signatureType", kind: "enum", T: () => ["SignatureType", SignatureType] },
+            { no: 5, name: "contentMessage", kind: "message", oneof: "body", T: () => ContentMessage },
+            { no: 6, name: "groupKeyRequest", kind: "message", oneof: "body", T: () => GroupKeyRequest },
+            { no: 7, name: "groupKeyResponse", kind: "message", oneof: "body", T: () => GroupKeyResponse }
         ]);
     }
 }
@@ -455,6 +481,22 @@ class StreamMessage$Type extends MessageType<StreamMessage> {
  */
 export const StreamMessage = new StreamMessage$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ContentMessage$Type extends MessageType<ContentMessage> {
+    constructor() {
+        super("ContentMessage", [
+            { no: 1, name: "content", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "contentType", kind: "enum", T: () => ["ContentType", ContentType] },
+            { no: 3, name: "encryptionType", kind: "enum", T: () => ["EncryptionType", EncryptionType] },
+            { no: 4, name: "groupKeyId", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "newGroupKey", kind: "message", T: () => GroupKey }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message ContentMessage
+ */
+export const ContentMessage = new ContentMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class GroupKeyRequest$Type extends MessageType<GroupKeyRequest> {
     constructor() {
         super("GroupKeyRequest", [
@@ -640,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 }
         ]);
     }
 }
@@ -687,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/StreamPartIdDataKeyDistribution.test.ts

@@ -0,0 +1,60 @@
+/* eslint-disable no-console */
+
+import { groupBy, range } from 'lodash'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { DhtAddress } from '@streamr/dht'
+
+describe('StreamPartIdDataKeyDistribution', () => {
+
+    it('partitions are well distributed', () => {
+
+        const streamId = 'stream'
+        const dataKeys = range(100).map((i) => {
+            const streamPartId = StreamPartIDUtils.parse(streamId + '#' + i)
+            return streamPartIdToDataKey(streamPartId)
+        })
+        
+        const byInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0])
+        expect(Object.keys(byInitials).length).toEqual(16)
+        console.log(Object.values(byInitials).map((a) => a.length))
+    })
+
+    it('streamIds are well distributed', () => {
+        const dataKeys = range(10000).map(() => {
+            const streamPartId = StreamPartIDUtils.parse(Math.random().toString(32).substr(2, 32) + '#0')
+            return streamPartIdToDataKey(streamPartId)
+        })
+        const byInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0])
+        expect(Object.keys(byInitials).length).toEqual(16)
+        console.log(Object.values(byInitials).map((a) => a.length))
+    })
+
+    it('streamPartIds are well distributed', () => {
+        const streamIds = range(10000).map(() => Math.random().toString(32).substr(2, 32))
+        const dataKeys: DhtAddress[] = []
+        streamIds.forEach((streamId) => {
+            range(100).forEach((i) => {
+                const streamPartId = StreamPartIDUtils.parse(streamId + '#' + i)
+                dataKeys.push(streamPartIdToDataKey(streamPartId))
+            })
+        })
+
+        const byInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0])
+        expect(Object.keys(byInitials).length).toEqual(16)
+        console.log(Object.values(byInitials).map((a) => a.length))
+    
+        const byTwoInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0] + dataKey[1])
+        expect(Object.keys(byTwoInitials).length).toEqual(16 * 16)
+        console.log(Object.values(byTwoInitials).map((a) => a.length))
+
+        const byThreeInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0] + dataKey[1] + dataKey[2])
+        expect(Object.keys(byThreeInitials).length).toEqual(16 * 16 * 16)
+        console.log(Object.values(byThreeInitials).map((a) => a.length))
+
+        const byFourInitials = groupBy(dataKeys, (dataKey: DhtAddress) => dataKey[0] + dataKey[1] + dataKey[2] + dataKey[3])
+        expect(Object.keys(byFourInitials).length).toEqual(16 * 16 * 16 * 16)
+        console.log(Object.values(byFourInitials).map((a) => a.length))
+    })
+
+})

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 foundData = nodes[0].stack.getLayer0Node().getDataFromDht(streamPartIdToDataKey(streamParts[0]))
+    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

@@ -1,17 +1,20 @@
 import {
     ContentType,
     EncryptionType,
-    GroupKeyRequest,
-    GroupKeyResponse,
     MessageID,
-    serializeGroupKeyRequest,
-    serializeGroupKeyResponse, SignatureType,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
 } from '@streamr/protocol'
 import { hexToBinary, toEthereumAddress, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
+import {
+    convertGroupKeyRequestToBytes,
+    convertGroupKeyResponseToBytes
+} from '../../src/logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
@@ -44,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],
@@ -72,7 +75,7 @@ describe('proxy group key exchange', () => {
         await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
         await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
-        const groupKeyRequest = new GroupKeyRequest({
+        const groupKeyRequest = new OldGroupKeyRequest({
             recipient: publisherUserId,
             requestId: 'requestId',
             rsaPublicKey: 'mockKey',
@@ -90,15 +93,15 @@ describe('proxy group key exchange', () => {
                 '0'
             ),
             messageType: StreamMessageType.GROUP_KEY_REQUEST,
-            contentType: ContentType.JSON,
+            contentType: ContentType.BINARY,
             encryptionType: EncryptionType.NONE,
-            content: serializeGroupKeyRequest(groupKeyRequest),
+            content: convertGroupKeyRequestToBytes(groupKeyRequest),
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
         })
 
         await Promise.all([
-            waitForEvent3(publisher.stack.getStreamrNode() as any, 'newMessage'),
+            waitForEvent3(publisher.stack.getContentDeliveryManager() as any, 'newMessage'),
             subscriber.broadcast(request)
         ])
     })
@@ -107,7 +110,7 @@ describe('proxy group key exchange', () => {
         await publisher.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.PUBLISH, publisherUserId)
         await subscriber.setProxies(STREAM_PART_ID, [proxyNodeDescriptor], ProxyDirection.SUBSCRIBE, subscriberUserId)
 
-        const groupKeyResponse = new GroupKeyResponse({
+        const groupKeyResponse = new OldGroupKeyResponse({
             recipient: publisherUserId,
             requestId: 'requestId',
             encryptedGroupKeys: []
@@ -122,15 +125,15 @@ describe('proxy group key exchange', () => {
                 '0'
             ),
             messageType: StreamMessageType.GROUP_KEY_RESPONSE,
-            contentType: ContentType.JSON,
+            contentType: ContentType.BINARY,
             encryptionType: EncryptionType.NONE,
-            content: serializeGroupKeyResponse(groupKeyResponse),
+            content: convertGroupKeyResponseToBytes(groupKeyResponse),
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
         })
 
         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)