@streamr/trackerless-network 0.0.1-tatum.0

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

@@ -0,0 +1,61 @@
+import { keyFromPeerDescriptor, ListeningRpcCommunicator } from '@streamr/dht'
+import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { PeerList } from '../PeerList'
+import { INeighborFinder } from './NeighborFinder'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { NetworkRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+
+interface NeighborUpdateManagerConfig {
+    ownStringId: string
+    randomGraphId: string
+    targetNeighbors: PeerList
+    nearbyContactPool: PeerList
+    neighborFinder: INeighborFinder
+    rpcCommunicator: ListeningRpcCommunicator
+}
+
+export class NeighborUpdateManagerServer implements INeighborUpdateRpc {
+
+    private readonly config: NeighborUpdateManagerConfig
+
+    constructor(config: NeighborUpdateManagerConfig) {
+        this.config = config
+    }
+
+    // INetworkRpc server method
+    async neighborUpdate(message: NeighborUpdate, _context: ServerCallContext): Promise<NeighborUpdate> {
+        if (this.config.targetNeighbors!.hasPeerWithStringId(message.senderId)) {
+            const newPeers = message.neighborDescriptors
+                .filter((peerDescriptor) => {
+                    const stringId = keyFromPeerDescriptor(peerDescriptor)
+                    return stringId !== this.config.ownStringId && !this.config.targetNeighbors.getStringIds().includes(stringId)
+                })
+            newPeers.forEach((peer) => this.config.nearbyContactPool.add(
+                new RemoteRandomGraphNode(
+                    peer,
+                    this.config.randomGraphId,
+                    toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator!.getRpcClientTransport()))
+                ))
+            )
+            this.config.neighborFinder!.start()
+            const response: NeighborUpdate = {
+                senderId: this.config.ownStringId,
+                randomGraphId: this.config.randomGraphId,
+                neighborDescriptors: this.config.targetNeighbors.getPeers().map((neighbor) => neighbor.getPeerDescriptor()),
+                removeMe: false
+            }
+            return response
+        } else {
+            const response: NeighborUpdate = {
+                senderId: this.config.ownStringId,
+                randomGraphId: this.config.randomGraphId,
+                neighborDescriptors: this.config.targetNeighbors.getPeers().map((neighbor) => neighbor.getPeerDescriptor()),
+                removeMe: true
+            }
+            return response
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+import { Remote } from '../Remote'
+import { DhtRpcOptions, keyFromPeerDescriptor, PeerDescriptor, UUID } from '@streamr/dht'
+import { InterleaveNotice, StreamHandshakeRequest } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { Logger } from '@streamr/utils'
+import { IHandshakeRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+
+const logger = new Logger(module)
+
+interface HandshakeResponse {
+    accepted: boolean
+    interleaveTarget?: PeerDescriptor
+}
+
+export class RemoteHandshaker extends Remote<IHandshakeRpcClient> {
+
+    async handshake(
+        ownPeerDescriptor: PeerDescriptor,
+        neighbors: string[],
+        concurrentHandshakeTargetId?: string,
+        interleavingFrom?: string
+    ): Promise<HandshakeResponse> {
+        const request: StreamHandshakeRequest = {
+            randomGraphId: this.graphId,
+            requestId: new UUID().toString(),
+            senderId: keyFromPeerDescriptor(ownPeerDescriptor),
+            neighbors,
+            concurrentHandshakeTargetId,
+            interleavingFrom,
+            senderDescriptor: ownPeerDescriptor
+        }
+        const options: DhtRpcOptions = {
+            sourceDescriptor: ownPeerDescriptor as PeerDescriptor,
+            targetDescriptor: this.remotePeerDescriptor as PeerDescriptor
+        }
+        try {
+            const response = await this.client.handshake(request, options)
+            return {
+                accepted: response.accepted,
+                interleaveTarget: response.interleaveTarget
+            }
+        } catch (err: any) {
+            logger.debug(`handshake to ${keyFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            return {
+                accepted: false
+            }
+        }
+    }
+
+    interleaveNotice(ownPeerDescriptor: PeerDescriptor, originatorDescriptor: PeerDescriptor): void {
+        const options: DhtRpcOptions = {
+            sourceDescriptor: ownPeerDescriptor as PeerDescriptor,
+            targetDescriptor: this.remotePeerDescriptor as PeerDescriptor,
+            notification: true
+        }
+        const notification: InterleaveNotice = {
+            randomGraphId: this.graphId,
+            interleaveTarget: originatorDescriptor,
+            senderId: keyFromPeerDescriptor(ownPeerDescriptor)
+        }
+        this.client.interleaveNotice(notification, options).catch(() => {
+            logger.debug('Failed to send interleaveNotice')
+        })
+    }
+}

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

@@ -0,0 +1,41 @@
+import { DhtRpcOptions, keyFromPeerDescriptor, PeerDescriptor } from '@streamr/dht'
+import { Logger } from '@streamr/utils'
+import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { Remote } from '../Remote'
+import { INeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+
+const logger = new Logger(module)
+
+interface UpdateNeighborsResponse {
+    peers: PeerDescriptor[]
+    removeMe: boolean
+}
+
+export class RemoteNeighborUpdateManager extends Remote<INeighborUpdateRpcClient> {
+
+    async updateNeighbors(ownPeerDescriptor: PeerDescriptor, neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
+        const options: DhtRpcOptions = {
+            sourceDescriptor: ownPeerDescriptor as PeerDescriptor,
+            targetDescriptor: this.remotePeerDescriptor as PeerDescriptor,
+        }
+        const request: NeighborUpdate = {
+            senderId: keyFromPeerDescriptor(ownPeerDescriptor),
+            randomGraphId: this.graphId,
+            neighborDescriptors: neighbors,
+            removeMe: false
+        }
+        try {
+            const response = await this.client.neighborUpdate(request, options)
+            return {
+                peers: response.neighborDescriptors!,
+                removeMe: response.removeMe
+            }
+        } catch (err: any) {
+            logger.debug(`updateNeighbors to ${keyFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            return {
+                peers: [],
+                removeMe: true
+            }
+        }
+    }
+}

package/src/logic/propagation/FifoMapWithTTL.ts

@@ -0,0 +1,108 @@
+import { Node, create } from 'yallist'
+
+interface Item<K, V> {
+    value: V
+    dropQueueNode: Node<K>
+    expiresAt: number
+}
+
+export interface FifoMapWithTtlOptions<K> {
+    ttlInMs: number
+    maxSize: number
+    onItemDropped?: (key: K) => void
+    timeProvider?: () => number
+    debugMode?: boolean
+}
+
+/**
+ * A "Map" implementation with a maximum size and TTL expiration on entries.
+ *
+ * When full, room is made for new entries by dropping existing by FIFO method.
+ *
+ * Entries have a TTL after which they are considered stale. Stale items are
+ * not returned when querying.
+ *
+ */
+export class FifoMapWithTTL<K, V> {
+    // class invariant: the keys present in `items` and `dropQueue` are the same set.
+    private readonly items = new Map<K, Item<K, V>>()
+    private readonly dropQueue = create<K>() // queue is used to determine deletion order when full
+    private readonly ttlInMs: number
+    private readonly maxSize: number
+    private readonly onItemDropped: (key: K) => void
+    private readonly timeProvider: () => number
+
+    constructor({
+        ttlInMs,
+        maxSize,
+        onItemDropped = () => {},
+        timeProvider = Date.now
+    }: FifoMapWithTtlOptions<K>) {
+        if (ttlInMs < 0) {
+            throw new Error(`ttlInMs (${ttlInMs}) cannot be < 0`)
+        }
+        if (maxSize < 0) {
+            throw new Error(`maxSize (${maxSize}) cannot be < 0`)
+        }
+        this.ttlInMs = ttlInMs
+        this.maxSize = maxSize
+        this.onItemDropped = onItemDropped
+        this.timeProvider = timeProvider
+    }
+
+    set(key: K, value: V): void {
+        if (this.maxSize === 0) {
+            return
+        }
+        if (this.items.size > this.maxSize) {
+            throw new Error('assertion error: maximum size exceeded')
+        }
+
+        // delete an existing entry if exists
+        this.delete(key)
+
+        // make room for new entry
+        if (this.items.size === this.maxSize) {
+            const keyToDel = this.dropQueue.shift()
+            if (keyToDel === undefined) {
+                throw new Error('assertion error: queue empty but still have items')
+            }
+            this.items.delete(keyToDel)
+            this.onItemDropped(keyToDel)
+        }
+
+        // add entry
+        const dropQueueNode = new Node<K>(key)
+        this.dropQueue.pushNode(dropQueueNode)
+        this.items.set(key, {
+            value,
+            dropQueueNode,
+            expiresAt: this.timeProvider() + this.ttlInMs
+        })
+    }
+
+    delete(key: K): void {
+        const item = this.items.get(key)
+        if (item !== undefined) {
+            this.items.delete(key)
+            this.dropQueue.removeNode(item.dropQueueNode)
+            this.onItemDropped(key)
+        }
+    }
+
+    get(key: K): V | undefined {
+        const item = this.items.get(key)
+        if (item === undefined) {
+            return undefined
+        }
+        if (item.expiresAt <= this.timeProvider()) {
+            this.delete(key)
+            return undefined
+        }
+        return item.value
+    }
+
+    values(): Item<K, V>[] {
+        return [...this.items.values()]
+    }
+}

package/src/logic/propagation/Propagation.ts

@@ -0,0 +1,83 @@
+import { StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { PropagationTask, PropagationTaskStore } from './PropagationTaskStore'
+
+type SendToNeighborFn = (neighborId: string, msg: StreamMessage) => Promise<void>
+
+interface ConstructorOptions {
+    sendToNeighbor: SendToNeighborFn
+    minPropagationTargets: number
+    ttl?: number
+    maxMessages?: number
+}
+
+const DEFAULT_MAX_MESSAGES = 150
+const DEFAULT_TTL = 30 * 1000
+
+/**
+ * Message propagation logic of a node. Given a message, this class will actively attempt to propagate it to
+ * `minPropagationTargets` neighbors until success or TTL expiration.
+ *
+ * Setting `minPropagationTargets = 0` effectively disables any propagation reattempts. A message will then
+ * only be propagated exactly once, to neighbors that are present at that moment, in a fire-and-forget manner.
+ */
+
+export class Propagation {
+    private readonly sendToNeighbor: SendToNeighborFn
+    private readonly minPropagationTargets: number
+    private readonly activeTaskStore: PropagationTaskStore
+
+    constructor({
+        sendToNeighbor,
+        minPropagationTargets,
+        ttl = DEFAULT_TTL,
+        maxMessages = DEFAULT_MAX_MESSAGES
+    }: ConstructorOptions) {
+        this.sendToNeighbor = sendToNeighbor
+        this.minPropagationTargets = minPropagationTargets
+        this.activeTaskStore = new PropagationTaskStore(ttl, maxMessages)
+    }
+
+    /**
+     * Node should invoke this when it learns about a new message
+     */
+    feedUnseenMessage(message: StreamMessage, targets: string[], source: string | null): void {
+        const task = {
+            message,
+            source,
+            handledNeighbors: new Set<string>()
+        }
+        this.activeTaskStore.add(task)
+        for (const target of targets) {
+            this.sendAndAwaitThenMark(task, target)
+        }
+    }
+
+    /**
+     * Node should invoke this when it learns about a new node stream assignment
+     */
+    onNeighborJoined(neighborId: string): void {
+        const tasksOfStream = this.activeTaskStore.get()
+        for (const task of tasksOfStream) {
+            this.sendAndAwaitThenMark(task, neighborId)
+        }
+    }
+
+    private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: string): void {
+        if (!handledNeighbors.has(neighborId) && neighborId !== source) {
+            (async () => {
+                try {
+                    await this.sendToNeighbor(neighborId, message)
+                } catch {
+                    return
+                }
+                // Side-note: due to asynchronicity, the task being modified at this point could already be stale and
+                // deleted from `activeTaskStore`. However, as modifying it or re-deleting it is pretty much
+                // inconsequential at this point, leaving the logic as is.
+                handledNeighbors.add(neighborId)
+                if (handledNeighbors.size >= this.minPropagationTargets) {
+                    this.activeTaskStore.delete(message.messageRef!)
+                }
+            })()
+        }
+    }
+}

package/src/logic/propagation/PropagationTaskStore.ts

@@ -0,0 +1,40 @@
+import { MessageRef, StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { FifoMapWithTTL } from './FifoMapWithTTL'
+
+export interface PropagationTask {
+    message: StreamMessage
+    source: string | null
+    handledNeighbors: Set<string>
+}
+
+/**
+ * Keeps track of propagation tasks for the needs of message propagation logic.
+ *
+ * Properties:
+ * - Allows fetching propagation tasks by StreamPartID
+ * - Upper bound on number of tasks stored, replacement policy if FIFO
+ * - Items have a TTL, after which they are considered stale and not returned when querying
+**/
+export class PropagationTaskStore {
+    private readonly tasks: FifoMapWithTTL<MessageRef, PropagationTask>
+
+    constructor(ttlInMs: number, maxTasks: number) {
+        this.tasks = new FifoMapWithTTL<MessageRef, PropagationTask>({
+            ttlInMs,
+            maxSize: maxTasks
+        })
+    }
+
+    get(): PropagationTask[] {
+        return this.tasks.values().map((task) => task.value)
+    }
+
+    add(task: PropagationTask): void {
+        const messageId = task.message.messageRef!
+        this.tasks.set(messageId, task)
+    }
+
+    delete(messageId: MessageRef): void {
+        this.tasks.delete(messageId) // causes `onKeyDropped` to be invoked
+    }
+}

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

@@ -0,0 +1,16 @@
+import { ContentMessage } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class ContentMessageTranslator {
+
+    static toProtobuf(msg: string): ContentMessage {
+        const translatedMessage: ContentMessage = {
+            body: msg
+        }
+        return translatedMessage
+    }
+
+    static toClientProtocol(msg: ContentMessage): string {
+        return msg.body
+    }
+}

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

@@ -0,0 +1,28 @@
+import { GroupKeyRequest as OldGroupKeyRequest } from '@streamr/protocol'
+import { GroupKeyRequest } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { EthereumAddress } from '@streamr/utils'
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class GroupKeyRequestTranslator {
+
+    static toProtobuf(msg: OldGroupKeyRequest): GroupKeyRequest {
+        const translated: GroupKeyRequest = {
+            recipient: msg.recipient,
+            requestId: msg.requestId,
+            rsaPublicKey: msg.rsaPublicKey,
+            groupKeyIds: msg.groupKeyIds
+        }
+        return translated
+    }
+
+    static toClientProtocol(msg: GroupKeyRequest): OldGroupKeyRequest {
+        const translated = new OldGroupKeyRequest({
+            recipient: msg.recipient as EthereumAddress,
+            requestId: msg.requestId,
+            rsaPublicKey: msg.rsaPublicKey,
+            groupKeyIds: msg.groupKeyIds
+        })
+        return translated
+    }
+
+}

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

@@ -0,0 +1,38 @@
+import { GroupKeyResponse as OldGroupKeyResponse, EncryptedGroupKey as OldEncryptedGroupKey } from '@streamr/protocol'
+import { EncryptedGroupKey, GroupKeyResponse } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { EthereumAddress } from '@streamr/utils'
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class GroupKeyResponseTranslator {
+
+    static toProtobuf(msg: OldGroupKeyResponse): GroupKeyResponse {
+
+        const encryptedGroupKeys = msg.encryptedGroupKeys.map((groupKey) => {
+            const encryptedGroupKey: EncryptedGroupKey = {
+                encryptedGroupKeyHex: groupKey.encryptedGroupKeyHex,
+                groupKeyId: groupKey.groupKeyId,
+                serialized: groupKey.serialized ?? undefined
+            }
+            return encryptedGroupKey
+        })
+        const translated: GroupKeyResponse = {
+            recipient: msg.recipient as string,
+            requestId: msg.requestId,
+            encryptedGroupKeys
+        }
+        return translated
+    }
+
+    static toClientProtocol(msg: GroupKeyResponse): OldGroupKeyResponse {
+        const encryptedGroupKeys = msg.encryptedGroupKeys.map((groupKey: EncryptedGroupKey) => new OldEncryptedGroupKey(
+            groupKey.groupKeyId,
+            groupKey.encryptedGroupKeyHex,
+            groupKey.serialized
+        ))
+        return new OldGroupKeyResponse({
+            requestId: msg.requestId,
+            recipient: msg.recipient as EthereumAddress,
+            encryptedGroupKeys
+        })
+    }
+}

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

@@ -0,0 +1,142 @@
+import {
+    MessageID,
+    StreamMessage as OldStreamMessage,
+    StreamMessageType as OldStreamMessageType,
+    MessageRef as OldMessageRef,
+    EncryptedGroupKey as OldEncryptedGroupKey,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse,
+    StreamID,
+} from '@streamr/protocol'
+import {
+    ContentMessage,
+    EncryptedGroupKey,
+    GroupKeyRequest,
+    GroupKeyResponse,
+    MessageRef,
+    StreamMessage,
+    StreamMessageType
+} from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ContentMessageTranslator } from './ContentMessageTranslator'
+import { EthereumAddress } from '@streamr/utils'
+import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
+import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class StreamMessageTranslator {
+
+    static toProtobuf(msg: OldStreamMessage): StreamMessage {
+        let content: Uint8Array
+        let contentType: StreamMessageType
+        if (msg.messageType === OldStreamMessageType.MESSAGE) {
+            content = ContentMessage.toBinary(ContentMessageTranslator.toProtobuf(msg.serializedContent))
+            contentType = StreamMessageType.MESSAGE
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
+            content = GroupKeyRequest.toBinary(
+                GroupKeyRequestTranslator.toProtobuf(
+                    OldGroupKeyRequest.deserialize(
+                        msg.serializedContent,
+                        OldStreamMessageType.GROUP_KEY_REQUEST) as OldGroupKeyRequest
+                )
+            )
+            contentType = StreamMessageType.GROUP_KEY_REQUEST
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
+            content = GroupKeyResponse.toBinary(
+                GroupKeyResponseTranslator.toProtobuf(
+                    OldGroupKeyResponse.deserialize(
+                        msg.serializedContent,
+                        OldStreamMessageType.GROUP_KEY_RESPONSE) as OldGroupKeyResponse
+                )
+            )
+            contentType = StreamMessageType.GROUP_KEY_RESPONSE
+        } else {
+            throw new Error('invalid message type')
+        }
+        const messageRef: MessageRef = {
+            timestamp: msg.getTimestamp(),
+            sequenceNumber: msg.getSequenceNumber(),
+            streamId: msg.getStreamId() as string,
+            streamPartition: msg.getStreamPartition(),
+            publisherId: msg.getPublisherId(),
+            messageChainId: msg.getMsgChainId()
+        }
+        let previousMessageRef: MessageRef | undefined = undefined
+        if (msg.getPreviousMessageRef()) {
+            previousMessageRef = {
+                timestamp: msg.getPreviousMessageRef()!.timestamp,
+                sequenceNumber: msg.getPreviousMessageRef()!.sequenceNumber,
+                streamId: msg.getStreamId() as string,
+                streamPartition: msg.getStreamPartition(),
+                publisherId: msg.getPublisherId(),
+                messageChainId: msg.getMsgChainId()
+            }
+        }
+        let newGroupKey: EncryptedGroupKey | undefined = undefined
+        if (msg.getNewGroupKey()) {
+            newGroupKey = {
+                encryptedGroupKeyHex: msg.getNewGroupKey()!.encryptedGroupKeyHex,
+                groupKeyId: msg.getNewGroupKey()!.groupKeyId,
+                serialized: msg.getNewGroupKey()!.serialized ?? undefined
+            }
+        }
+        const translated: StreamMessage = {
+            content: content,
+            encryptionType: msg.encryptionType,
+            messageRef: messageRef,
+            previousMessageRef,
+            messageType: contentType,
+            signature: msg.signature,
+            groupKeyId: msg.groupKeyId ?? undefined,
+            newGroupKey,
+        }
+        return translated
+    }
+
+    static toClientProtocol<T>(msg: StreamMessage): OldStreamMessage<T> {
+        let content: string
+        let contentType: OldStreamMessageType
+        if (msg.messageType === StreamMessageType.MESSAGE) {
+            contentType = OldStreamMessageType.MESSAGE
+            content = ContentMessageTranslator.toClientProtocol(ContentMessage.fromBinary(msg.content))
+        } else if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+            contentType = OldStreamMessageType.GROUP_KEY_REQUEST
+            content = GroupKeyRequestTranslator.toClientProtocol(GroupKeyRequest.fromBinary(msg.content)).serialize()
+        } else if (msg.messageType === StreamMessageType.GROUP_KEY_RESPONSE) {
+            contentType = OldStreamMessageType.GROUP_KEY_RESPONSE
+            content = GroupKeyResponseTranslator.toClientProtocol(GroupKeyResponse.fromBinary(msg.content)).serialize()
+        } else {
+            throw new Error('invalid message type')
+        }
+        const messageId = new MessageID(
+            msg.messageRef!.streamId as StreamID,
+            msg.messageRef!.streamPartition,
+            Number(msg.messageRef!.timestamp),
+            msg.messageRef!.sequenceNumber,
+            msg.messageRef!.publisherId as EthereumAddress,
+            msg.messageRef!.messageChainId
+        )
+        let prevMsgRef: OldMessageRef | undefined = undefined
+        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!.groupKeyId,
+                msg.newGroupKey!.encryptedGroupKeyHex,
+                msg.newGroupKey!.serialized
+            )
+        }
+        const translated = new OldStreamMessage<T>({
+            signature: msg.signature,
+            newGroupKey,
+            groupKeyId: msg.groupKeyId,
+            content,
+            messageType: contentType,
+            encryptionType: msg.encryptionType,
+            messageId,
+            prevMsgRef
+        })
+        return translated
+    }
+}