@streamr/trackerless-network 100.0.0-pretestnet.4 → 100.0.0-rc.0

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

@@ -1,42 +1,35 @@
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
+import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { Logger, scheduleAtInterval } from '@streamr/utils'
-import { INeighborFinder } from './NeighborFinder'
+import { NeighborFinder } from './NeighborFinder'
 import { NodeList } from '../NodeList'
 import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
 import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateManagerConfig {
     localPeerDescriptor: PeerDescriptor
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
-    neighborFinder: INeighborFinder
+    neighborFinder: NeighborFinder
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     neighborUpdateInterval: number
+    neighborTargetCount: number
+    ongoingHandshakes: Set<DhtAddress>
 }
 
 const logger = new Logger(module)
 
-export interface INeighborUpdateManager {
-    start(): Promise<void>
-    stop(): void
-}
-
-export class NeighborUpdateManager implements INeighborUpdateManager {
+export class NeighborUpdateManager {
 
     private readonly abortController: AbortController
     private readonly config: NeighborUpdateManagerConfig
-    private readonly client: ProtoRpcClient<NeighborUpdateRpcClient>
     private readonly rpcLocal: NeighborUpdateRpcLocal
 
     constructor(config: NeighborUpdateManagerConfig) {
         this.abortController = new AbortController()
-        this.client = toProtoRpcClient(new NeighborUpdateRpcClient(config.rpcCommunicator.getRpcClientTransport()))
         this.rpcLocal = new NeighborUpdateRpcLocal(config)
         this.config = config
         this.config.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate',
@@ -53,17 +46,23 @@ export class NeighborUpdateManager implements INeighborUpdateManager {
 
     private async updateNeighborInfo(): Promise<void> {
         logger.trace(`Updating neighbor info to nodes`)
-        const neighborDescriptors = this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
-        await Promise.allSettled(this.config.targetNeighbors.getAll().map(async (neighbor) => {
-            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(neighborDescriptors)
+        const neighborDescriptors = this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
+        await Promise.allSettled(this.config.neighbors.getAll().map(async (neighbor) => {
+            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.config.streamPartId, neighborDescriptors)
             if (res.removeMe) {
-                this.config.targetNeighbors.remove(neighbor.getPeerDescriptor())
-                this.config.neighborFinder.start([getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())])
+                const nodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
+                this.config.neighbors.remove(nodeId)
+                this.config.neighborFinder.start([nodeId])
             }
         }))
     }
 
     private createRemote(targetPeerDescriptor: PeerDescriptor): NeighborUpdateRpcRemote {
-        return new NeighborUpdateRpcRemote(this.config.localPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
+        return new NeighborUpdateRpcRemote(
+            this.config.localPeerDescriptor,
+            targetPeerDescriptor,
+            this.config.rpcCommunicator,
+            NeighborUpdateRpcClient
+        )
     }
 }

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

@@ -1,22 +1,22 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { INeighborFinder } from './NeighborFinder'
+import { NeighborFinder } from './NeighborFinder'
 import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
-    neighborFinder: INeighborFinder
+    neighborFinder: NeighborFinder
     rpcCommunicator: ListeningRpcCommunicator
+    neighborTargetCount: number
+    ongoingHandshakes: Set<DhtAddress>
 }
 
 export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
@@ -27,39 +27,49 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
         this.config = config
     }
 
+    private updateContacts(neighborDescriptors: PeerDescriptor[]): void {
+        const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const newPeerDescriptors = neighborDescriptors.filter((peerDescriptor) => {
+            const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+            return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
+        })
+        newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
+            new DeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peerDescriptor,
+                this.config.rpcCommunicator,
+                DeliveryRpcClient
+            ))
+        )
+    }
+
+    private createResponse(removeMe: boolean): NeighborUpdate {
+        return {
+            streamPartId: this.config.streamPartId,
+            neighborDescriptors: this.config.neighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
+            removeMe
+        }
+    }
+
     // INeighborUpdateRpc server method
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-        if (this.config.targetNeighbors.hasNodeById(senderId)) {
-            const newPeerDescriptors = message.neighborDescriptors
-                .filter((peerDescriptor) => {
-                    const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-                    const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-                    return nodeId !== ownNodeId && !this.config.targetNeighbors.getIds().includes(nodeId)
-                })
-            newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
-                new DeliveryRpcRemote(
-                    this.config.localPeerDescriptor,
-                    peerDescriptor,
-                    this.config.streamPartId,
-                    toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
-                ))
-            )
-            this.config.neighborFinder.start()
-            const response: NeighborUpdate = {
-                streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-                removeMe: false
-            }
-            return response
+        this.updateContacts(message.neighborDescriptors)
+        if (!this.config.neighbors.has(senderId) && !this.config.ongoingHandshakes.has(senderId)) {
+            return this.createResponse(true)
         } else {
-            const response: NeighborUpdate = {
-                streamPartId: this.config.streamPartId,
-                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
-                removeMe: true
+            const isOverNeighborCount = this.config.neighbors.size() > this.config.neighborTargetCount
+                // Motivation: We don't know the remote's neighborTargetCount setting here. We only ask to cut connections
+                // if the remote has a "sufficient" number of neighbors, where "sufficient" means our neighborTargetCount
+                // setting.
+                && message.neighborDescriptors.length > this.config.neighborTargetCount
+            if (!isOverNeighborCount) {
+                this.config.neighborFinder.start()
+            } else {
+                this.config.neighbors.remove(senderId)
             }
-            return response
+            return this.createResponse(isOverNeighborCount)
         }
     }
 }

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

@@ -1,8 +1,8 @@
-import { PeerDescriptor, Remote } from '@streamr/dht'
+import { PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { INeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
@@ -11,11 +11,11 @@ interface UpdateNeighborsResponse {
     removeMe: boolean
 }
 
-export class NeighborUpdateRpcRemote extends Remote<INeighborUpdateRpcClient> {
+export class NeighborUpdateRpcRemote extends RpcRemote<NeighborUpdateRpcClient> {
 
-    async updateNeighbors(neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
+    async updateNeighbors(streamPartId: StreamPartID, neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
         const request: NeighborUpdate = {
-            streamPartId: this.getServiceId(),
+            streamPartId,
             neighborDescriptors: neighbors,
             removeMe: false
         }

package/src/logic/node-info/NodeInfoClient.ts

@@ -0,0 +1,23 @@
+import { DhtCallContext, PeerDescriptor } from '@streamr/dht'
+import { RpcCommunicator } from '@streamr/proto-rpc'
+import { NodeInfo } from '../../NetworkStack'
+import { NodeInfoRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NodeInfoRpcRemote } from './NodeInfoRpcRemote'
+
+export class NodeInfoClient {
+    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly rpcCommunicator: RpcCommunicator<DhtCallContext>
+
+    constructor(ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RpcCommunicator<DhtCallContext>) {
+        this.ownPeerDescriptor = ownPeerDescriptor
+        this.rpcCommunicator = rpcCommunicator
+    }
+
+    async getInfo(node: PeerDescriptor): Promise<NodeInfo> {
+        const remote = new NodeInfoRpcRemote(this.ownPeerDescriptor, node, this.rpcCommunicator, NodeInfoRpcClient)
+        // TODO remove casting when we validate NodeInfoResponse messages and therefore can annotate
+        // each of the field as required in the decorated type
+        return remote.getInfo() as unknown as NodeInfo
+    }
+
+}

package/src/logic/node-info/NodeInfoRpcLocal.ts

@@ -0,0 +1,28 @@
+import { NodeInfoRequest, NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { INodeInfoRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { NetworkStack } from '../../NetworkStack'
+import { ListeningRpcCommunicator } from '@streamr/dht'
+
+export const NODE_INFO_RPC_SERVICE_ID = 'system/node-info-rpc'
+
+export class NodeInfoRpcLocal implements INodeInfoRpc {
+    
+    private readonly stack: NetworkStack
+    private readonly rpcCommunicator: ListeningRpcCommunicator
+ 
+    constructor(stack: NetworkStack, rpcCommunicator: ListeningRpcCommunicator) {
+        this.stack = stack
+        this.rpcCommunicator = rpcCommunicator
+        this.registerDefaultServerMethods()
+    }
+
+    private registerDefaultServerMethods(): void {
+        this.rpcCommunicator.registerRpcMethod(NodeInfoRequest, NodeInfoResponse, 'getInfo',
+            () => this.getInfo())
+    }
+ 
+    async getInfo(): Promise<NodeInfoResponse> {
+        return this.stack.createNodeInfo()
+    }
+
+}

package/src/logic/node-info/NodeInfoRpcRemote.ts

@@ -0,0 +1,11 @@
+import { NodeInfoResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { NodeInfoRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { RpcRemote } from '@streamr/dht'
+
+export class NodeInfoRpcRemote extends RpcRemote<NodeInfoRpcClient> {
+
+    async getInfo(): Promise<NodeInfoResponse> {
+        return this.getClient().getInfo({}, this.formDhtRpcOptions())
+    }
+
+}

package/src/logic/propagation/Propagation.ts

@@ -1,8 +1,8 @@
-import { NodeID } from '../../identifiers'
+import { DhtAddress } from '@streamr/dht'
 import { StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { PropagationTask, PropagationTaskStore } from './PropagationTaskStore'
 
-type SendToNeighborFn = (neighborId: NodeID, msg: StreamMessage) => Promise<void>
+type SendToNeighborFn = (neighborId: DhtAddress, msg: StreamMessage) => Promise<void>
 
 interface ConstructorOptions {
     sendToNeighbor: SendToNeighborFn
@@ -41,11 +41,11 @@ export class Propagation {
     /**
      * Node should invoke this when it learns about a new message
      */
-    feedUnseenMessage(message: StreamMessage, targets: NodeID[], source: NodeID | null): void {
+    feedUnseenMessage(message: StreamMessage, targets: DhtAddress[], source: DhtAddress | null): void {
         const task = {
             message,
             source,
-            handledNeighbors: new Set<NodeID>()
+            handledNeighbors: new Set<DhtAddress>()
         }
         this.activeTaskStore.add(task)
         for (const target of targets) {
@@ -56,15 +56,16 @@ export class Propagation {
     /**
      * Node should invoke this when it learns about a new node stream assignment
      */
-    onNeighborJoined(neighborId: NodeID): void {
+    onNeighborJoined(neighborId: DhtAddress): void {
         const tasks = this.activeTaskStore.get()
         for (const task of tasks) {
             this.sendAndAwaitThenMark(task, neighborId)
         }
     }
 
-    private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: NodeID): void {
+    private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: DhtAddress): void {
         if (!handledNeighbors.has(neighborId) && neighborId !== source) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             (async () => {
                 try {
                     await this.sendToNeighbor(neighborId, message)

package/src/logic/propagation/PropagationTaskStore.ts

@@ -1,11 +1,11 @@
-import { NodeID } from '../../identifiers'
+import { DhtAddress } from '@streamr/dht'
 import { MessageRef, StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { FifoMapWithTTL } from './FifoMapWithTTL'
 
 export interface PropagationTask {
     message: StreamMessage
     source: string | null
-    handledNeighbors: Set<NodeID>
+    handledNeighbors: Set<DhtAddress>
 }
 
 /**

package/src/logic/protocol-integration/stream-message/GroupKeyRequestTranslator.ts

@@ -10,7 +10,7 @@ export class GroupKeyRequestTranslator {
             recipientId: hexToBinary(msg.recipient),
             requestId: msg.requestId,
             rsaPublicKey: utf8ToBinary(msg.rsaPublicKey),
-            groupKeyIds: msg.groupKeyIds
+            groupKeyIds: [...msg.groupKeyIds]
         }
         return translated
     }

package/src/logic/protocol-integration/stream-message/GroupKeyResponseTranslator.ts

@@ -6,11 +6,10 @@ import { toEthereumAddress, binaryToHex, hexToBinary } from '@streamr/utils'
 export class GroupKeyResponseTranslator {
 
     static toProtobuf(msg: OldGroupKeyResponse): GroupKeyResponse {
-
         const groupKeys = msg.encryptedGroupKeys.map((groupKey) => {
             return {
                 data: groupKey.data,
-                id: groupKey.groupKeyId
+                id: groupKey.id
             }
         })
         const translated: GroupKeyResponse = {

package/src/logic/protocol-integration/stream-message/StreamMessageTranslator.ts

@@ -4,10 +4,9 @@ import {
     StreamMessageType as OldStreamMessageType,
     MessageRef as OldMessageRef,
     EncryptedGroupKey as OldEncryptedGroupKey,
-    GroupKeyRequest as OldGroupKeyRequest,
-    GroupKeyResponse as OldGroupKeyResponse,
     StreamID,
     EncryptionType as OldEncryptionType,
+    SignatureType as OldSignatureType,
     ContentType as OldContentType
 } from '@streamr/protocol'
 import {
@@ -17,13 +16,11 @@ import {
     GroupKeyRequest,
     GroupKeyResponse,
     MessageRef,
+    SignatureType,
     StreamMessage,
-    StreamMessageType,
     MessageID
 } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { toEthereumAddress, binaryToHex, binaryToUtf8, hexToBinary, utf8ToBinary } from '@streamr/utils'
-import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
-import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
+import { toEthereumAddress, binaryToHex, hexToBinary } from '@streamr/utils'
 
 const oldToNewEncryptionType = (type: OldEncryptionType): EncryptionType => {
     if (type === OldEncryptionType.AES) {
@@ -39,36 +36,39 @@ const newToOldEncryptionType = (type: EncryptionType): OldEncryptionType => {
     return OldEncryptionType.NONE
 }
 
+const oldToNewContentType = (type: OldContentType): ContentType => {
+    if (type === OldContentType.JSON) {
+        return ContentType.JSON
+    }
+    return ContentType.BINARY
+}
+
+const newToOldContentType = (type: ContentType): OldContentType => {
+    if (type === ContentType.JSON) {
+        return OldContentType.JSON
+    }
+    return OldContentType.BINARY
+}
+
+const oldToNewSignatureType = (type: OldSignatureType): SignatureType => {
+    if (type === OldSignatureType.LEGACY_SECP256K1) {
+        return SignatureType.LEGACY_SECP256K1
+    }
+    return SignatureType.SECP256K1
+}
+
+const newToOldSignatureType = (type: SignatureType): OldSignatureType => {
+    if (type === SignatureType.LEGACY_SECP256K1) {
+        return OldSignatureType.LEGACY_SECP256K1
+    }
+    return OldSignatureType.SECP256K1
+
+}
+
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class StreamMessageTranslator {
 
     static toProtobuf(msg: OldStreamMessage): StreamMessage {
-        let content: Uint8Array
-        let messageType: StreamMessageType
-        if (msg.messageType === OldStreamMessageType.MESSAGE) {
-            content = msg.serializedContent
-            messageType = StreamMessageType.MESSAGE
-        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
-            content = GroupKeyRequest.toBinary(
-                GroupKeyRequestTranslator.toProtobuf(
-                    OldGroupKeyRequest.deserialize(
-                        binaryToUtf8(msg.serializedContent),
-                        OldStreamMessageType.GROUP_KEY_REQUEST) as OldGroupKeyRequest
-                )
-            )
-            messageType = StreamMessageType.GROUP_KEY_REQUEST
-        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
-            content = GroupKeyResponse.toBinary(
-                GroupKeyResponseTranslator.toProtobuf(
-                    OldGroupKeyResponse.deserialize(
-                        binaryToUtf8(msg.serializedContent),
-                        OldStreamMessageType.GROUP_KEY_RESPONSE) as OldGroupKeyResponse
-                )
-            )
-            messageType = StreamMessageType.GROUP_KEY_RESPONSE
-        } else {
-            throw new Error('invalid message type')
-        }
         const messageId: MessageID = {
             timestamp: msg.getTimestamp(),
             sequenceNumber: msg.getSequenceNumber(),
@@ -78,52 +78,84 @@ export class StreamMessageTranslator {
             messageChainId: msg.getMsgChainId()
         }
         let previousMessageRef: MessageRef | undefined = undefined
-        if (msg.getPreviousMessageRef()) {
+        if (msg.prevMsgRef) {
             previousMessageRef = {
-                timestamp: msg.getPreviousMessageRef()!.timestamp,
-                sequenceNumber: msg.getPreviousMessageRef()!.sequenceNumber,
+                timestamp: msg.prevMsgRef.timestamp,
+                sequenceNumber: msg.prevMsgRef.sequenceNumber
             }
         }
-        let newGroupKey: GroupKey | undefined = undefined
-        if (msg.getNewGroupKey()) {
-            newGroupKey = {
-                id: msg.getNewGroupKey()!.groupKeyId,
-                data: msg.getNewGroupKey()!.data
+        let body: StreamMessage['body']
+        if (msg.messageType === OldStreamMessageType.MESSAGE) {
+            let newGroupKey: GroupKey | undefined = undefined
+            if (msg.newGroupKey) {
+                newGroupKey = {
+                    id: msg.newGroupKey.id,
+                    data: msg.newGroupKey.data
+                }
+            }
+            body = {
+                oneofKind: 'contentMessage',
+                contentMessage: {
+                    content: msg.content,
+                    contentType: oldToNewContentType(msg.contentType),
+                    encryptionType: oldToNewEncryptionType(msg.encryptionType),
+                    groupKeyId: msg.groupKeyId ?? undefined,
+                    newGroupKey
+                }
+            }
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
+            body = {
+                oneofKind: 'groupKeyRequest',
+                groupKeyRequest: GroupKeyRequest.fromBinary(msg.content)
             }
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
+            body = {
+                oneofKind: 'groupKeyResponse',
+                groupKeyResponse: GroupKeyResponse.fromBinary(msg.content)
+            }
+        } else {
+            throw new Error('invalid message type')
         }
         const translated: StreamMessage = {
             messageId,
             previousMessageRef,
-            content,
-            messageType,
-            contentType: ContentType.JSON,
-            encryptionType: oldToNewEncryptionType(msg.encryptionType),
-            groupKeyId: msg.groupKeyId ?? undefined,
-            newGroupKey,
-            signature: msg.signature
+            signature: msg.signature,
+            signatureType: oldToNewSignatureType(msg.signatureType),
+            body
         }
         return translated
     }
 
     static toClientProtocol(msg: StreamMessage): OldStreamMessage {
-        let content: Uint8Array
         let messageType: OldStreamMessageType
-        if (msg.messageType === StreamMessageType.MESSAGE) {
+        let content: Uint8Array
+        let contentType: OldContentType = OldContentType.BINARY
+        let encryptionType: OldEncryptionType = OldEncryptionType.NONE
+        let newGroupKey: OldEncryptedGroupKey | undefined = undefined
+        let groupKeyId: string | undefined = undefined
+        if (msg.body.oneofKind === 'contentMessage') {
             messageType = OldStreamMessageType.MESSAGE
-            content = msg.content
-        } else if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+            content = msg.body.contentMessage.content
+            contentType = newToOldContentType(msg.body.contentMessage.contentType)
+            encryptionType = newToOldEncryptionType(msg.body.contentMessage.encryptionType)
+            if (msg.body.contentMessage.newGroupKey) {
+                newGroupKey = new OldEncryptedGroupKey(
+                    msg.body.contentMessage.newGroupKey.id,
+                    msg.body.contentMessage.newGroupKey.data
+                )
+            }
+            groupKeyId = msg.body.contentMessage.groupKeyId
+        } else if (msg.body.oneofKind === 'groupKeyRequest') {
             messageType = OldStreamMessageType.GROUP_KEY_REQUEST
             try {
-                const parsedRequest = GroupKeyRequest.fromBinary(msg.content)
-                content = utf8ToBinary(GroupKeyRequestTranslator.toClientProtocol(parsedRequest).serialize())
+                content = GroupKeyRequest.toBinary(msg.body.groupKeyRequest)
             } catch (err) {
                 throw new Error(`invalid group key request: ${err}`)
             }
-        } else if (msg.messageType === StreamMessageType.GROUP_KEY_RESPONSE) {
+        } else if (msg.body.oneofKind === 'groupKeyResponse') {
             messageType = OldStreamMessageType.GROUP_KEY_RESPONSE
             try {
-                const parsedResponse = GroupKeyResponse.fromBinary(msg.content)
-                content = utf8ToBinary(GroupKeyResponseTranslator.toClientProtocol(parsedResponse).serialize())
+                content = GroupKeyResponse.toBinary(msg.body.groupKeyResponse)
             } catch (err) {
                 throw new Error(`invalid group key response: ${err}`)
             }
@@ -142,23 +174,17 @@ export class StreamMessageTranslator {
         if (msg.previousMessageRef) {
             prevMsgRef = new OldMessageRef(Number(msg.previousMessageRef.timestamp), msg.previousMessageRef.sequenceNumber)
         }
-        let newGroupKey: OldEncryptedGroupKey | undefined = undefined
-        if (msg.newGroupKey) {
-            newGroupKey = new OldEncryptedGroupKey(
-                msg.newGroupKey.id,
-                msg.newGroupKey.data,
-            )
-        }
         const translated = new OldStreamMessage({
             messageId,
             prevMsgRef,
-            content,
             messageType,
-            contentType: OldContentType.JSON,
-            encryptionType: newToOldEncryptionType(msg.encryptionType),
-            groupKeyId: msg.groupKeyId,
-            newGroupKey,
-            signature: msg.signature
+            content,
+            contentType,
+            signature: msg.signature,
+            signatureType: newToOldSignatureType(msg.signatureType),
+            encryptionType,
+            groupKeyId,
+            newGroupKey
         })
         return translated
     }

package/src/logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils.ts

@@ -0,0 +1,37 @@
+import { 
+    StreamMessage as OldStreamMessage,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse
+} from '@streamr/protocol'
+import { StreamMessageTranslator } from './StreamMessageTranslator'
+import {
+    StreamMessage,
+    GroupKeyRequest,
+    GroupKeyResponse
+} from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
+import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
+
+export function convertStreamMessageToBytes(oldStreamMessage: OldStreamMessage): Uint8Array {
+    return StreamMessage.toBinary(StreamMessageTranslator.toProtobuf(oldStreamMessage))
+}
+
+export function convertBytesToStreamMessage(bytes: Uint8Array): OldStreamMessage {
+    return StreamMessageTranslator.toClientProtocol(StreamMessage.fromBinary(bytes))
+}
+
+export const convertGroupKeyRequestToBytes = (oldGroupKeyRequest: OldGroupKeyRequest): Uint8Array => {
+    return GroupKeyRequest.toBinary(GroupKeyRequestTranslator.toProtobuf(oldGroupKeyRequest))
+}
+
+export const convertBytesToGroupKeyRequest = (bytes: Uint8Array): OldGroupKeyRequest => {
+    return GroupKeyRequestTranslator.toClientProtocol(GroupKeyRequest.fromBinary(bytes))
+}
+
+export const convertGroupKeyResponseToBytes = (oldGroupKeyResponse: OldGroupKeyResponse): Uint8Array => {
+    return GroupKeyResponse.toBinary(GroupKeyResponseTranslator.toProtobuf(oldGroupKeyResponse))
+}
+
+export const convertBytesToGroupKeyResponse = (bytes: Uint8Array): OldGroupKeyResponse => {
+    return GroupKeyResponseTranslator.toClientProtocol(GroupKeyResponse.fromBinary(bytes))
+}