@streamr/trackerless-network 101.0.0-beta.2 → 101.0.0-beta.4

package/src/exports.ts

@@ -1,13 +1,16 @@
-export { NetworkStack, NetworkOptions, NodeInfo } from './NetworkStack'
 export { NetworkNode, createNetworkNode } from './NetworkNode'
-export { ContentDeliveryManagerOptions } from './logic/ContentDeliveryManager'
-export { ProxyDirection, GroupKeyRequest, GroupKeyResponse } from './proto/packages/trackerless-network/protos/NetworkRpc'
-export { streamPartIdToDataKey } from './logic/ContentDeliveryManager'
+export { NetworkOptions, NetworkStack, NodeInfo } from './NetworkStack'
+export { ContentDeliveryManagerOptions, streamPartIdToDataKey } from './logic/ContentDeliveryManager'
 export {
-    convertStreamMessageToBytes,
-    convertBytesToStreamMessage,
-    convertGroupKeyRequestToBytes,
-    convertBytesToGroupKeyRequest,
-    convertGroupKeyResponseToBytes,
-    convertBytesToGroupKeyResponse
-} from './logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'
+    ContentType,
+    EncryptionType,
+    GroupKey,
+    GroupKeyRequest,
+    GroupKeyResponse,
+    MessageID,
+    MessageRef,
+    ProxyDirection,
+    SignatureType,
+    StreamMessage
+} from './proto/packages/trackerless-network/protos/NetworkRpc'
+

package/src/logic/ContentDeliveryLayerNode.ts

@@ -1,37 +1,36 @@
-import { EventEmitter } from 'eventemitter3'
 import {
-    PeerDescriptor,
-    ListeningRpcCommunicator,
-    ITransport,
     ConnectionLocker,
     DhtAddress,
+    ITransport,
+    ListeningRpcCommunicator,
+    PeerDescriptor,
     getNodeIdFromPeerDescriptor,
 } from '@streamr/dht'
+import { Logger, StreamPartID, addManagedEventListener } from '@streamr/utils'
+import { EventEmitter } from 'eventemitter3'
 import {
-    StreamMessage,
+    CloseTemporaryConnection,
     LeaveStreamPartNotice,
+    MessageID,
     MessageRef,
+    StreamMessage,
     TemporaryConnectionRequest,
     TemporaryConnectionResponse,
-    MessageID,
-    CloseTemporaryConnection,
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { NodeList } from './NodeList'
 import { ContentDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcLocal } from './ContentDeliveryRpcLocal'
 import { ContentDeliveryRpcRemote } from './ContentDeliveryRpcRemote'
+import { DiscoveryLayerNode } from './DiscoveryLayerNode'
 import { DuplicateMessageDetector } from './DuplicateMessageDetector'
-import { Logger, addManagedEventListener } from '@streamr/utils'
+import { NodeList } from './NodeList'
+import { Inspector } from './inspect/Inspector'
 import { Handshaker } from './neighbor-discovery/Handshaker'
-import { Propagation } from './propagation/Propagation'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { ContentDeliveryRpcLocal } from './ContentDeliveryRpcLocal'
+import { Propagation } from './propagation/Propagation'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
-import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { markAndCheckDuplicate } from './utils'
-import { DiscoveryLayerNode } from './DiscoveryLayerNode'
-import { StreamPartID } from '@streamr/protocol'
 
 export interface Events {
     message: (message: StreamMessage) => void

package/src/logic/ContentDeliveryManager.ts

@@ -8,14 +8,13 @@ import {
     getDhtAddressFromRaw,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
-import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
 import {
     EthereumAddress,
     Logger,
     Metric,
     MetricsContext,
     MetricsDefinition,
-    RateMetric
+    RateMetric, StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID
 } from '@streamr/utils'
 import { createHash } from 'crypto'
 import { EventEmitter } from 'eventemitter3'

package/src/logic/ContentDeliveryRpcLocal.ts

@@ -1,4 +1,6 @@
-import { ListeningRpcCommunicator, PeerDescriptor, DhtCallContext, DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { StreamPartID } from '@streamr/utils'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
     LeaveStreamPartNotice,
@@ -7,8 +9,6 @@ import {
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IContentDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { StreamPartID } from '@streamr/protocol'
 
 export interface ContentDeliveryRpcLocalOptions {
     localPeerDescriptor: PeerDescriptor

package/src/logic/ContentDeliveryRpcRemote.ts

@@ -1,11 +1,10 @@
 import { RpcRemote } from '@streamr/dht'
-import { Logger } from '@streamr/utils'
+import { Logger, StreamPartID } from '@streamr/utils'
 import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ContentDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 

package/src/logic/createContentDeliveryLayerNode.ts

@@ -6,7 +6,7 @@ import { StrictContentDeliveryLayerNodeOptions, ContentDeliveryLayerNode } from
 import { NodeList } from './NodeList'
 import { Propagation } from './propagation/Propagation'
 import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { MarkOptional } from 'ts-essentials'
+import type { MarkOptional } from 'ts-essentials'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'

package/src/logic/formStreamPartDeliveryServiceId.ts

@@ -1,5 +1,5 @@
 import { ServiceID } from '@streamr/dht'
-import { StreamPartID } from '@streamr/protocol'
+import { StreamPartID } from '@streamr/utils'
 
 export const formStreamPartContentDeliveryServiceId = (streamPartId: StreamPartID): ServiceID => {
     // could be "content-delivery" instead of "delivery", but that is a breaking change

package/src/logic/inspect/Inspector.ts

@@ -1,10 +1,9 @@
-import { PeerDescriptor, ConnectionLocker, LockID, DhtAddress, getNodeIdFromPeerDescriptor, ListeningRpcCommunicator } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, ListeningRpcCommunicator, LockID, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { Logger, StreamPartID, waitForEvent3 } from '@streamr/utils'
 import { MessageID } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
 import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { Logger, waitForEvent3 } from '@streamr/utils'
 import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
-import { StreamPartID } from '@streamr/protocol'
+import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
 
 interface InspectorOptions {
     localPeerDescriptor: PeerDescriptor

package/src/logic/neighbor-discovery/HandshakeRpcLocal.ts

@@ -1,11 +1,4 @@
-import { 
-    InterleaveRequest,
-    InterleaveResponse,
-    StreamPartHandshakeRequest,
-    StreamPartHandshakeResponse
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { NodeList } from '../NodeList'
 import {
     DhtAddress,
     DhtAddressRaw,
@@ -14,11 +7,17 @@ import {
     getDhtAddressFromRaw,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
+import { Logger, StreamPartID } from '@streamr/utils'
+import {
+    InterleaveRequest,
+    InterleaveResponse,
+    StreamPartHandshakeRequest,
+    StreamPartHandshakeResponse
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { HandshakeRpcRemote } from './HandshakeRpcRemote'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { Logger } from '@streamr/utils'
-import { StreamPartID } from '@streamr/protocol'
+import { NodeList } from '../NodeList'
+import { HandshakeRpcRemote } from './HandshakeRpcRemote'
 
 interface HandshakeRpcLocalOptions {
     streamPartId: StreamPartID

package/src/logic/neighbor-discovery/HandshakeRpcRemote.ts

@@ -1,9 +1,8 @@
 import { DhtAddress, PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
-import { Logger } from '@streamr/utils'
+import { Logger, StreamPartID } from '@streamr/utils'
 import { v4 } from 'uuid'
 import { InterleaveRequest, InterleaveResponse, StreamPartHandshakeRequest } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { HandshakeRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 

package/src/logic/neighbor-discovery/Handshaker.ts

@@ -1,19 +1,18 @@
-import { DhtAddress, PeerDescriptor, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { NodeList } from '../NodeList'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import {
-    ContentDeliveryRpcClient, HandshakeRpcClient
-} from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { Logger, StreamPartID } from '@streamr/utils'
 import {
     InterleaveRequest,
     InterleaveResponse,
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { Logger } from '@streamr/utils'
-import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRemote'
+import {
+    ContentDeliveryRpcClient, HandshakeRpcClient
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
+import { NodeList } from '../NodeList'
 import { HandshakeRpcLocal } from './HandshakeRpcLocal'
-import { StreamPartID } from '@streamr/protocol'
+import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRemote'
 
 interface HandshakerOptions {
     localPeerDescriptor: PeerDescriptor

package/src/logic/neighbor-discovery/NeighborUpdateManager.ts

@@ -1,12 +1,11 @@
-import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { Logger, StreamPartID, scheduleAtInterval } from '@streamr/utils'
+import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { Logger, scheduleAtInterval } from '@streamr/utils'
-import { NeighborFinder } from './NeighborFinder'
 import { NodeList } from '../NodeList'
-import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
+import { NeighborFinder } from './NeighborFinder'
 import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
-import { StreamPartID } from '@streamr/protocol'
+import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
 
 interface NeighborUpdateManagerOptions {
     localPeerDescriptor: PeerDescriptor

package/src/logic/neighbor-discovery/NeighborUpdateRpcLocal.ts

@@ -1,12 +1,12 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { StreamPartID } from '@streamr/utils'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { NodeList } from '../NodeList'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
+import { NodeList } from '../NodeList'
 import { NeighborFinder } from './NeighborFinder'
-import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateRpcLocalOptions {
     localPeerDescriptor: PeerDescriptor

package/src/logic/neighbor-discovery/NeighborUpdateRpcRemote.ts

@@ -1,8 +1,7 @@
 import { PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { Logger } from '@streamr/utils'
+import { Logger, StreamPartID } from '@streamr/utils'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 

package/src/logic/proxy/ProxyClient.ts

@@ -6,8 +6,7 @@ import {
     PeerDescriptor,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
-import { StreamPartID } from '@streamr/protocol'
-import { EthereumAddress, Logger, addManagedEventListener, wait } from '@streamr/utils'
+import { EthereumAddress, Logger, StreamPartID, addManagedEventListener, wait } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
 import {
@@ -18,14 +17,14 @@ import {
     StreamMessage
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ContentDeliveryRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcLocal } from '../ContentDeliveryRpcLocal'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { DuplicateMessageDetector } from '../DuplicateMessageDetector'
 import { NodeList } from '../NodeList'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { ContentDeliveryRpcLocal } from '../ContentDeliveryRpcLocal'
+import { formStreamPartContentDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
 import { Propagation } from '../propagation/Propagation'
 import { markAndCheckDuplicate } from '../utils'
 import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
-import { formStreamPartContentDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
 
 // TODO use options option or named constant?
 export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -1,17 +1,16 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { 
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { EthereumAddress, Logger, StreamPartID, binaryToHex, toEthereumAddress } from '@streamr/utils'
+import { EventEmitter } from 'eventemitter3'
+import {
     ProxyConnectionRequest,
     ProxyConnectionResponse,
     ProxyDirection,
     StreamMessage
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { EventEmitter } from 'eventemitter3'
-import { EthereumAddress, Logger, binaryToHex, toEthereumAddress } from '@streamr/utils'
-import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -1,17 +1,17 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { 
+import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { StreamPartID } from '@streamr/utils'
+import { Empty } from '../../proto/google/protobuf/empty'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import {
     CloseTemporaryConnection,
     TemporaryConnectionRequest,
     TemporaryConnectionResponse
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { NodeList } from '../NodeList'
+import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { Empty } from '../../proto/google/protobuf/empty'
-import { StreamPartID } from '@streamr/protocol'
+import { NodeList } from '../NodeList'
 
 interface TemporaryConnectionRpcLocalOptions {
     rpcCommunicator: ListeningRpcCommunicator

package/test/benchmark/StreamPartIdDataKeyDistribution.test.ts

@@ -1,9 +1,9 @@
 /* eslint-disable no-console */
 
+import { DhtAddress } from '@streamr/dht'
+import { StreamPartIDUtils } from '@streamr/utils'
 import { groupBy, range } from 'lodash'
 import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { StreamPartIDUtils } from '@streamr/protocol'
-import { DhtAddress } from '@streamr/dht'
 
 describe('StreamPartIdDataKeyDistribution', () => {
 

package/test/benchmark/first-message.ts

@@ -9,24 +9,20 @@ import {
     Simulator
 } from '@streamr/dht'
 import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    SignatureType,
-    StreamMessage,
-    StreamMessageType,
+    hexToBinary,
     StreamPartID,
     StreamPartIDUtils,
     toStreamID,
-    toStreamPartID
-} from '@streamr/protocol'
-import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
+    toStreamPartID,
+    utf8ToBinary, waitForEvent3
+} from '@streamr/utils'
 import fs from 'fs'
-import { NetworkNode } from '../../src/NetworkNode'
+import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { streamPartIdToDataKey } from '../../src/logic/ContentDeliveryManager'
-import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
 import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
+import { NetworkNode } from '../../src/NetworkNode'
+import { ContentType, EncryptionType, SignatureType } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
 
 const numNodes = 10000
 
@@ -86,25 +82,28 @@ const measureJoiningTime = async () => {
     console.log(stream)
     publishInterval = setInterval(() => {
         i += 1
-        const streamMessage = new StreamMessage({
-            messageId: new MessageID(
-                StreamPartIDUtils.getStreamID(stream),
-                0,
-                i,
-                Math.floor(Math.random() * 20000),
-                '2222' as any,
-                'msgChainId'
-            ),
-            content: utf8ToBinary(JSON.stringify({
-                hello: 'world'
-            })),
-            messageType: StreamMessageType.MESSAGE,
-            contentType: ContentType.JSON,
-            encryptionType: EncryptionType.NONE,
+        const streamMessage = {
+            messageId: {
+                streamId: StreamPartIDUtils.getStreamID(stream),
+                streamPartition: 0,
+                timestamp: i,
+                sequenceNumber: Math.floor(Math.random() * 20000),
+                publisherId: hexToBinary('0x2222'),
+                messageChainId: 'msgChainId'
+            },
+            body: {
+                oneofKind: 'contentMessage' as const,
+                contentMessage: {
+                    content: utf8ToBinary(JSON.stringify({
+                        hello: 'world'
+                    })),
+                    contentType: ContentType.JSON,
+                    encryptionType: EncryptionType.NONE,
+                }
+            },
             signature: hexToBinary('0x1234'),
             signatureType: SignatureType.SECP256K1,
-
-        })
+        }
         streamParts.get(stream)!.broadcast(streamMessage)
     }, 1000)
     // get random node from network to use as entrypoint

package/test/end-to-end/content-delivery-layer-node-with-real-connections.test.ts

@@ -1,12 +1,11 @@
 import { ConnectionManager, DhtNode, PeerDescriptor } from '@streamr/dht'
-import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
-import { waitForCondition } from '@streamr/utils'
-import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
-import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
+import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
+import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { ControlLayerNode } from '../../src/logic/ControlLayerNode'
 import { DiscoveryLayerNode } from '../../src/logic/DiscoveryLayerNode'
+import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
+import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('content delivery layer node with real connections', () => {
 

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

@@ -1,16 +1,7 @@
-import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    MessageRef,
-    SignatureType,
-    StreamMessage,
-    StreamMessageType,
-    StreamPartIDUtils
-} from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
-import { 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('stream#0')
@@ -47,25 +38,32 @@ describe('inspect', () => {
 
     let inspectorNode: NetworkNode
 
-    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,
-        contentType: ContentType.JSON,
-        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'),
-    })
+    }
     
     beforeEach(async () => {
         publisherNode = createNetworkNode({

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)),