@streamr/trackerless-network 101.0.0-beta.1 → 101.0.0-beta.3

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

@@ -1,42 +1,44 @@
+import { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamPartID, StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
+import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import {
     ContentType,
     EncryptionType,
-    MessageID,
-    MessageRef,
+    ProxyDirection,
     SignatureType,
-    StreamMessage,
-    StreamMessageType,
-    StreamPartID,
-    StreamPartIDUtils
-} from '@streamr/protocol'
-import { randomEthereumAddress } from '@streamr/test-utils'
-import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
-import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { StreamMessage as InternalStreamMessage, ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+    StreamMessage
+} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const PROXIED_NODE_USER_ID = randomEthereumAddress()
 
 const createMessage = (streamPartId: StreamPartID): StreamMessage => {
-    return new StreamMessage({ 
-        messageId: new MessageID(
-            StreamPartIDUtils.getStreamID(streamPartId),
-            StreamPartIDUtils.getStreamPartition(streamPartId),
-            666,
-            0,
-            randomEthereumAddress(),
-            'msgChainId'
-        ),
-        prevMsgRef: new MessageRef(665, 0),
-        content: utf8ToBinary(JSON.stringify({
-            hello: 'world'
-        })),
-        messageType: StreamMessageType.MESSAGE,
-        contentType: ContentType.JSON,
-        encryptionType: EncryptionType.NONE,
+    return { 
+        messageId: {
+            streamId: StreamPartIDUtils.getStreamID(streamPartId),
+            streamPartition: StreamPartIDUtils.getStreamPartition(streamPartId),
+            timestamp: 666,
+            sequenceNumber: 0,
+            publisherId: hexToBinary(randomEthereumAddress()),
+            messageChainId: 'msgChainId'
+        },
+        previousMessageRef: {
+            timestamp: 665,
+            sequenceNumber: 0
+        },
+        body: {
+            oneofKind: 'contentMessage',
+            contentMessage: {
+                content: utf8ToBinary(JSON.stringify({
+                    hello: 'world'
+                })),
+                contentType: ContentType.JSON,
+                encryptionType: EncryptionType.NONE,
+            }
+        },
         signatureType: SignatureType.SECP256K1,
         signature: hexToBinary('0x1234'),
-    })
+    }
 }
 
 describe('proxy and full node', () => {
@@ -111,13 +113,13 @@ describe('proxy and full node', () => {
 
         await Promise.all([
             waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
+                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart1)),
             waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
+                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart2)),
             waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
+                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart3)),
             waitForEvent3(proxyNode.stack.getContentDeliveryManager() as any, 'newMessage', 5000, 
-                (streamMessage: InternalStreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
+                (streamMessage: StreamMessage) => streamMessage.messageId!.streamId === StreamPartIDUtils.getStreamID(regularStreamPart4)),
             proxiedNode.broadcast(createMessage(regularStreamPart1)),
             proxiedNode.broadcast(createMessage(regularStreamPart2)),
             proxiedNode.broadcast(createMessage(regularStreamPart3)),

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

@@ -1,43 +1,46 @@
-import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    MessageRef,
-    SignatureType,
-    StreamMessage,
-    StreamMessageType,
-    StreamPartIDUtils
-} from '@streamr/protocol'
+import { DhtAddress } from '@streamr/dht'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { StreamPartIDUtils, hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
-import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import {
+    ContentType,
+    EncryptionType,
+    ProxyDirection,
+    SignatureType,
+    StreamMessage
+} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { DhtAddress } from '@streamr/dht'
 
 const PROXIED_NODE_USER_ID = randomEthereumAddress()
 const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
-const MESSAGE = new StreamMessage({
-    messageId: new MessageID(
-        StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-        StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-        666,
-        0,
-        randomEthereumAddress(),
-        'msgChainId'
-    ),
-    prevMsgRef: new MessageRef(665, 0),
-    content: utf8ToBinary(JSON.stringify({
-        hello: 'world'
-    })),
-    messageType: StreamMessageType.MESSAGE,
-    encryptionType: EncryptionType.NONE,
+const MESSAGE: StreamMessage = {
+    messageId: {
+        streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+        streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
+        timestamp: 666,
+        sequenceNumber: 0,
+        publisherId: hexToBinary(randomEthereumAddress()),
+        messageChainId: 'msgChainId'
+    },
+    previousMessageRef: {
+        timestamp: 665,
+        sequenceNumber: 0
+    },
+    body: {
+        oneofKind: 'contentMessage',
+        contentMessage: {
+            content: utf8ToBinary(JSON.stringify({
+                hello: 'world'
+            })),
+            contentType: ContentType.JSON,
+            encryptionType: EncryptionType.NONE,
+        }
+    },
     signatureType: SignatureType.SECP256K1,
-    signature: hexToBinary('0x1234'),
-    contentType: ContentType.JSON
-})
+    signature: hexToBinary('0x1234')
+}
 
 describe('Proxy connections', () => {
 

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

@@ -1,21 +1,9 @@
 import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    GroupKeyRequest as OldGroupKeyRequest,
-    GroupKeyResponse as OldGroupKeyResponse,
-    SignatureType,
-    StreamMessage,
-    StreamMessageType,
-    StreamPartIDUtils
-} from '@streamr/protocol'
-import { hexToBinary, toEthereumAddress, waitForEvent3 } from '@streamr/utils'
+    StreamPartIDUtils,
+    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 { ProxyDirection, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
@@ -75,30 +63,27 @@ 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 OldGroupKeyRequest({
-            recipient: publisherUserId,
-            requestId: 'requestId',
-            rsaPublicKey: 'mockKey',
-            groupKeyIds: [
-                'mock'
-            ],
-        })
-        const request = new StreamMessage({
-            messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-                Date.now(),
-                0,
-                subscriberUserId,
-                '0'
-            ),
-            messageType: StreamMessageType.GROUP_KEY_REQUEST,
-            contentType: ContentType.BINARY,
-            encryptionType: EncryptionType.NONE,
-            content: convertGroupKeyRequestToBytes(groupKeyRequest),
+        const request: StreamMessage = {
+            messageId: {
+                streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
+                timestamp: Date.now(),
+                sequenceNumber: 0,
+                publisherId: hexToBinary(subscriberUserId),
+                messageChainId: '0'
+            },
+            body: {
+                oneofKind: 'groupKeyRequest' as const,
+                groupKeyRequest: {
+                    requestId: 'requestId',
+                    recipientId: hexToBinary(publisherUserId),
+                    rsaPublicKey: new Uint8Array(),
+                    groupKeyIds: ['mock']
+                }
+            },
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
-        })
+        }
 
         await Promise.all([
             waitForEvent3(publisher.stack.getContentDeliveryManager() as any, 'newMessage'),
@@ -110,27 +95,26 @@ 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 OldGroupKeyResponse({
-            recipient: publisherUserId,
-            requestId: 'requestId',
-            encryptedGroupKeys: []
-        })
-        const response = new StreamMessage({
-            messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-                Date.now(),
-                0,
-                publisherUserId,
-                '0'
-            ),
-            messageType: StreamMessageType.GROUP_KEY_RESPONSE,
-            contentType: ContentType.BINARY,
-            encryptionType: EncryptionType.NONE,
-            content: convertGroupKeyResponseToBytes(groupKeyResponse),
+        const response: StreamMessage = {
+            messageId: {
+                streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
+                timestamp: Date.now(),
+                sequenceNumber: 0,
+                publisherId: hexToBinary(publisherUserId),
+                messageChainId: '0'
+            },
+            body: {
+                oneofKind: 'groupKeyResponse' as const,
+                groupKeyResponse: {
+                    requestId: 'requestId',
+                    recipientId: hexToBinary(publisherUserId),
+                    groupKeys: []
+                }
+            },
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('1234')
-        })
+        }
 
         await Promise.all([
             waitForEvent3(subscriber.stack.getContentDeliveryManager() as any, 'newMessage'),

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

@@ -1,7 +1,6 @@
 import { getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'

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

@@ -1,10 +1,9 @@
-import { StreamPartIDUtils } from '@streamr/protocol'
+import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('Full node network with WebSocket connections only', () => {
 

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

@@ -1,11 +1,10 @@
 import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
+import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
 import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { StreamPartIDUtils } from '@streamr/protocol'
-import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
 
 describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
     const otherNodeCount = 64

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

@@ -1,11 +1,10 @@
 import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
-import { Logger, waitForCondition } from '@streamr/utils'
+import { Logger, StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
+import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
 import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { StreamPartIDUtils } from '@streamr/protocol'
-import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
 
 const logger = new Logger(module)
 

package/test/integration/ContentDeliveryManager.test.ts

@@ -3,12 +3,11 @@ import {
     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 { StreamPartIDUtils, waitForCondition, waitForEvent3 } from '@streamr/utils'
+import { ContentDeliveryManager, Events } from '../../src/logic/ContentDeliveryManager'
 import { ControlLayerNode } from '../../src/logic/ControlLayerNode'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('ContentDeliveryManager', () => {
 

package/test/integration/ContentDeliveryRpcRemote.test.ts

@@ -1,21 +1,20 @@
 import {
     ListeningRpcCommunicator,
-    Simulator,
+    NodeType,
     PeerDescriptor,
-    SimulatorTransport,
-    NodeType
+    Simulator,
+    SimulatorTransport
 } from '@streamr/dht'
+import { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
-import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { Empty } from '../../src/proto/google/protobuf/empty'
 import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { Empty } from '../../src/proto/google/protobuf/empty'
-import { waitForCondition } from '@streamr/utils'
+import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { createStreamMessage } from '../utils/utils'
-import { StreamPartIDUtils } from '@streamr/protocol'
-import { randomEthereumAddress } from '@streamr/test-utils'
 
 describe('ContentDeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator

package/test/integration/HandshakeRpcRemote.test.ts

@@ -1,7 +1,3 @@
-import {
-    StreamPartHandshakeRequest,
-    StreamPartHandshakeResponse
-} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
     ListeningRpcCommunicator,
     NodeType,
@@ -9,11 +5,15 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
+import { StreamPartIDUtils } from '@streamr/utils'
+import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
+import {
+    StreamPartHandshakeRequest,
+    StreamPartHandshakeResponse
+} from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
-import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('HandshakeRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator

package/test/integration/Handshakes.test.ts

@@ -1,19 +1,19 @@
-import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
 import {
+    ListeningRpcCommunicator,
     NodeType,
     PeerDescriptor,
-    ListeningRpcCommunicator,
     Simulator,
     SimulatorTransport,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
+import { StreamPartIDUtils } from '@streamr/utils'
+import { NodeList } from '../../src/logic/NodeList'
+import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
+import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
+import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
     HandshakeRpcClient
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { NodeList } from '../../src/logic/NodeList'
-import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
-import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshakes', () => {
 

package/test/integration/Inspect.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamPartIDUtils } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -5,12 +5,12 @@ import {
     Simulator,
     SimulatorTransport
 } from '@streamr/dht'
+import { StreamPartIDUtils } from '@streamr/utils'
 import { NeighborUpdateRpcRemote } from '../../src/logic/neighbor-discovery/NeighborUpdateRpcRemote'
 import { NeighborUpdate } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import {
     NeighborUpdateRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('NeighborUpdateRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator

package/test/integration/NetworkNode.test.ts

@@ -1,15 +1,7 @@
 import { PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
-import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    MessageRef, SignatureType,
-    StreamMessage,
-    StreamMessageType,
-    StreamPartIDUtils
-} from '@streamr/protocol'
-import { EthereumAddress, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, hexToBinary, utf8ToBinary, waitForCondition } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
+import { ContentType, EncryptionType, SignatureType, StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('test#0')
@@ -64,31 +56,38 @@ describe('NetworkNode', () => {
     })
 
     it('wait for join + broadcast and subscribe', async () => {
-        const streamMessage = new StreamMessage({
-            messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-                StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-                666,
-                0,
-                '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as EthereumAddress,
-                'msgChainId'
-            ),
-            prevMsgRef: new MessageRef(665, 0),
-            content: utf8ToBinary(JSON.stringify({
-                hello: 'world'
-            })),
-            contentType: ContentType.JSON,
-            messageType: StreamMessageType.MESSAGE,
-            encryptionType: EncryptionType.NONE,
+        const streamMessage: StreamMessage = {
+            messageId: {
+                streamId: StreamPartIDUtils.getStreamID(STREAM_PART_ID),
+                streamPartition: StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
+                timestamp: 666,
+                sequenceNumber: 0,
+                publisherId: hexToBinary('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
+                messageChainId: 'msgChainId'
+            },
+            previousMessageRef: {
+                timestamp: 665,
+                sequenceNumber: 0
+            },
+            body: {
+                oneofKind: 'contentMessage',
+                contentMessage: {
+                    content: utf8ToBinary(JSON.stringify({
+                        hello: 'world'
+                    })),
+                    contentType: ContentType.JSON,
+                    encryptionType: EncryptionType.NONE,
+                }
+            },
             signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('0x1234'),
-        })
+        }
 
         let msgCount = 0
         await node1.join(STREAM_PART_ID)
         node1.addMessageListener((msg) => {
-            expect(msg.messageId.timestamp).toEqual(666)
-            expect(msg.getSequenceNumber()).toEqual(0)
+            expect(msg.messageId!.timestamp).toEqual(666)
+            expect(msg.messageId!.sequenceNumber).toEqual(0)
             msgCount += 1
         })
         await node2.broadcast(streamMessage)

package/test/integration/NetworkRpc.test.ts

@@ -1,17 +1,16 @@
+import { DhtCallContext } from '@streamr/dht'
 import {
-    RpcCommunicator,
     ProtoRpcClient,
+    RpcCommunicator,
     toProtoRpcClient
 } from '@streamr/proto-rpc'
-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 { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
-import { createStreamMessage } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { DhtCallContext } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/protocol'
-import { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { createStreamMessage } from '../utils/utils'
 
 describe('Network RPC', () => {
     let rpcCommunicator1: RpcCommunicator<DhtCallContext>

package/test/integration/NetworkStack.test.ts

@@ -1,8 +1,8 @@
-import {
-    StreamPartIDUtils
-} from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { waitForCondition } from '@streamr/utils'
+import {
+    StreamPartIDUtils,
+    waitForCondition
+} from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 

package/test/integration/NodeInfoRpc.test.ts

@@ -1,10 +1,9 @@
-import { Simulator, SimulatorTransport, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
-import { createMockPeerDescriptor } from '../utils/utils'
 import { NodeInfoClient } from '../../src/logic/node-info/NodeInfoClient'
 import { NODE_INFO_RPC_SERVICE_ID } from '../../src/logic/node-info/NodeInfoRpcLocal'
-import { StreamPartIDUtils } from '@streamr/protocol'
-import { waitForCondition } from '@streamr/utils'
+import { createMockPeerDescriptor } from '../utils/utils'
 
 // TODO add Jest utility so that the normalization is not needed (NET-1254)
 const normalizePeerDescriptor = (peerDescriptor: PeerDescriptor) => {

package/test/integration/Propagation.test.ts

@@ -1,11 +1,10 @@
 import { Simulator } from '@streamr/dht'
-import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { waitForCondition } from '@streamr/utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { createMockPeerDescriptor, createMockContentDeliveryLayerNodeAndDhtNode, createStreamMessage } from '../utils/utils'
 import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
+import { createMockContentDeliveryLayerNodeAndDhtNode, createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('Propagation', () => {
     const entryPointDescriptor = createMockPeerDescriptor()

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

@@ -1,11 +1,10 @@
-import { PeerDescriptor, Simulator, SimulatorTransport, LatencyType } from '@streamr/dht'
+import { LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+import { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { NetworkStack } from '../../src/NetworkStack'
 import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { StreamPartIDUtils } from '@streamr/protocol'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { waitForCondition } from '@streamr/utils'
-import { randomEthereumAddress } from '@streamr/test-utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('stream#0')