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

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

@@ -1,197 +0,0 @@
-import {
-    ContentType as OldContentType,
-    EncryptedGroupKey as OldEncryptedGroupKey,
-    EncryptionType as OldEncryptionType,
-    MessageID as OldMessageID,
-    MessageRef as OldMessageRef,
-    SignatureType as OldSignatureType,
-    StreamID,
-    StreamMessage as OldStreamMessage,
-    StreamMessageType as OldStreamMessageType
-} from '@streamr/protocol'
-import {
-    ContentType,
-    EncryptionType,
-    GroupKey,
-    GroupKeyRequest,
-    GroupKeyResponse,
-    MessageID,
-    MessageRef,
-    SignatureType,
-    StreamMessage
-} from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { binaryToHex, hexToBinary, toEthereumAddress } from '@streamr/utils'
-
-const oldToNewEncryptionType = (type: OldEncryptionType): EncryptionType => {
-    if (type === OldEncryptionType.AES) {
-        return EncryptionType.AES
-    }
-    return EncryptionType.NONE
-}
-
-const newToOldEncryptionType = (type: EncryptionType): OldEncryptionType => {
-    if (type === EncryptionType.AES) {
-        return OldEncryptionType.AES
-    }
-    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
-    }
-    if (type === OldSignatureType.ERC_1271) {
-        return SignatureType.ERC_1271
-    }
-    return SignatureType.SECP256K1
-}
-
-const newToOldSignatureType = (type: SignatureType): OldSignatureType => {
-    if (type === SignatureType.LEGACY_SECP256K1) {
-        return OldSignatureType.LEGACY_SECP256K1
-    }
-    if (type === SignatureType.ERC_1271) {
-        return OldSignatureType.ERC_1271
-    }
-    return OldSignatureType.SECP256K1
-
-}
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class StreamMessageTranslator {
-
-    static toProtobuf(msg: OldStreamMessage): StreamMessage {
-        const messageId: MessageID = {
-            timestamp: msg.getTimestamp(),
-            sequenceNumber: msg.getSequenceNumber(),
-            streamId: msg.getStreamId() as string,
-            streamPartition: msg.getStreamPartition(),
-            publisherId: hexToBinary(msg.getPublisherId()),
-            messageChainId: msg.getMsgChainId()
-        }
-        let previousMessageRef: MessageRef | undefined = undefined
-        if (msg.prevMsgRef) {
-            previousMessageRef = {
-                timestamp: msg.prevMsgRef.timestamp,
-                sequenceNumber: msg.prevMsgRef.sequenceNumber
-            }
-        }
-        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,
-            signature: msg.signature,
-            signatureType: oldToNewSignatureType(msg.signatureType),
-            body
-        }
-        return translated
-    }
-
-    static toClientProtocol(msg: StreamMessage): OldStreamMessage {
-        let messageType: OldStreamMessageType
-        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.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 {
-                content = GroupKeyRequest.toBinary(msg.body.groupKeyRequest)
-            } catch (err) {
-                throw new Error(`invalid group key request: ${err}`)
-            }
-        } else if (msg.body.oneofKind === 'groupKeyResponse') {
-            messageType = OldStreamMessageType.GROUP_KEY_RESPONSE
-            try {
-                content = GroupKeyResponse.toBinary(msg.body.groupKeyResponse)
-            } catch (err) {
-                throw new Error(`invalid group key response: ${err}`)
-            }
-        } else {
-            throw new Error('invalid message type')
-        }
-        const messageId = new OldMessageID(
-            msg.messageId!.streamId as StreamID,
-            msg.messageId!.streamPartition,
-            Number(msg.messageId!.timestamp),
-            msg.messageId!.sequenceNumber,
-            toEthereumAddress(binaryToHex(msg.messageId!.publisherId, true)),
-            msg.messageId!.messageChainId
-        )
-        let prevMsgRef: OldMessageRef | undefined = undefined
-        if (msg.previousMessageRef) {
-            prevMsgRef = new OldMessageRef(Number(msg.previousMessageRef.timestamp), msg.previousMessageRef.sequenceNumber)
-        }
-        const translated = new OldStreamMessage({
-            messageId,
-            prevMsgRef,
-            messageType,
-            content,
-            contentType,
-            signature: msg.signature,
-            signatureType: newToOldSignatureType(msg.signatureType),
-            encryptionType,
-            groupKeyId,
-            newGroupKey
-        })
-        return translated
-    }
-}

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

@@ -1,37 +0,0 @@
-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))
-}

package/test/unit/GroupKeyResponseTranslator.test.ts

@@ -1,39 +0,0 @@
-import { GroupKeyResponseTranslator } from '../../src/logic/protocol-integration/stream-message/GroupKeyResponseTranslator'
-import {
-    GroupKeyResponse as OldGroupKeyResponse,
-    EncryptedGroupKey as OldEncryptedGroupKey
-} from '@streamr/protocol'
-import { EthereumAddress, hexToBinary } from '@streamr/utils'
-import { GroupKey, GroupKeyResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-
-describe('GroupKeyResponseTranslator', () => {
-
-    const oldGroupKeyResponse = new OldGroupKeyResponse({
-        requestId: 'request',
-        recipient: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' as EthereumAddress,
-        encryptedGroupKeys: [ new OldEncryptedGroupKey('id', hexToBinary('0000')) ]
-    })
-    const newGroupKey: GroupKey = {
-        id: 'id',
-        data: hexToBinary('0000')
-    }
-    const newGroupKeyResponse: GroupKeyResponse = {
-        requestId: 'request',
-        recipientId: hexToBinary('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'),
-        groupKeys: [ newGroupKey ]
-    }
-
-    it('translates old protocol to protobuf', () => {
-        const translated = GroupKeyResponseTranslator.toProtobuf(oldGroupKeyResponse)
-        expect(translated.groupKeys).toEqual(newGroupKeyResponse.groupKeys)
-        expect(translated.recipientId).toEqual(newGroupKeyResponse.recipientId)
-        expect(translated.requestId).toEqual(newGroupKeyResponse.requestId)
-    })
-
-    it('translates protobuf to old protocol', () => {
-        const translated = GroupKeyResponseTranslator.toClientProtocol(newGroupKeyResponse)
-        expect(translated.encryptedGroupKeys).toEqual(oldGroupKeyResponse.encryptedGroupKeys)
-        expect(translated.recipient).toEqual(oldGroupKeyResponse.recipient)
-        expect(translated.requestId).toEqual(oldGroupKeyResponse.requestId)
-    })
-})

package/test/unit/StreamMessageTranslator.test.ts

@@ -1,71 +0,0 @@
-import {
-    EncryptionType,
-    MessageID,
-    StreamMessage as OldStreamMessage,
-    StreamMessageType as OldStreamMessageType,
-    StreamPartIDUtils,
-    ContentType,
-    SignatureType
-} from '@streamr/protocol'
-import { binaryToHex, binaryToUtf8, hexToBinary, toEthereumAddress, utf8ToBinary } from '@streamr/utils'
-import { StreamMessageTranslator } from '../../src/logic/protocol-integration/stream-message/StreamMessageTranslator'
-import { createStreamMessage } from '../utils/utils'
-
-const STREAM_PART_ID = StreamPartIDUtils.parse('TEST#0')
-
-describe('StreamMessageTranslator', () => {
-
-    const publisherId = toEthereumAddress('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
-    const signature = hexToBinary('0x1234')
-    const protobufMsg = createStreamMessage(
-        JSON.stringify({ hello: 'WORLD' }),
-        STREAM_PART_ID,
-        publisherId
-    )
-    const messageId = new MessageID(
-        StreamPartIDUtils.getStreamID(STREAM_PART_ID),
-        StreamPartIDUtils.getStreamPartition(STREAM_PART_ID),
-        Date.now(),
-        0,
-        publisherId,
-        'test',
-    )
-    const oldProtocolMsg = new OldStreamMessage({
-        messageId,
-        content: utf8ToBinary(JSON.stringify({ hello: 'WORLD' })),
-        contentType: ContentType.JSON,
-        messageType: OldStreamMessageType.MESSAGE,
-        encryptionType: EncryptionType.NONE,
-        signatureType: SignatureType.SECP256K1,
-        signature,
-    })
-
-    it('translates old protocol to protobuf', () => {
-        const translated = StreamMessageTranslator.toProtobuf(oldProtocolMsg)
-        expect(translated.messageId!.streamId).toEqual(StreamPartIDUtils.getStreamID(STREAM_PART_ID))
-        expect(translated.messageId!.streamPartition).toEqual(StreamPartIDUtils.getStreamPartition(STREAM_PART_ID))
-        expect(translated.messageId!.timestamp).toBeGreaterThanOrEqual(0)
-        expect(translated.messageId!.sequenceNumber).toEqual(0)
-        expect(binaryToHex(translated.messageId!.publisherId, true)).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
-        expect(translated.previousMessageRef).toEqual(undefined)
-        expect(translated.body.oneofKind).toEqual('contentMessage')
-        expect((translated.body as any).contentMessage.groupKeyId).toEqual(undefined)
-        expect(translated.signature).toStrictEqual(signature)
-        expect(JSON.parse(binaryToUtf8((translated.body as any).contentMessage.content))).toEqual({ hello: 'WORLD' })
-    })
-
-    it('translates protobuf to old protocol', () => {
-        const translated = StreamMessageTranslator.toClientProtocol(protobufMsg)
-        expect(translated.messageId.streamId).toEqual(StreamPartIDUtils.getStreamID(STREAM_PART_ID))
-        expect(translated.messageId.streamPartition).toEqual(StreamPartIDUtils.getStreamPartition(STREAM_PART_ID))
-        expect(translated.messageId.timestamp).toBeGreaterThanOrEqual(0)
-        expect(translated.messageId.sequenceNumber).toEqual(0)
-        expect(translated.getPublisherId()).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
-        expect(translated.prevMsgRef).toEqual(undefined)
-        expect(translated.messageType).toEqual(OldStreamMessageType.MESSAGE)
-        expect(translated.contentType).toEqual(0)
-        expect(translated.groupKeyId).toEqual(undefined)
-        expect(translated.signature).toStrictEqual(signature)
-        expect(translated.getParsedContent()).toEqual({ hello: 'WORLD' })
-    })
-})

package/test/unit/oldStreamMessageBinaryUtils.test.ts

@@ -1,39 +0,0 @@
-import {
-    ContentType,
-    EncryptionType,
-    MessageID,
-    MessageRef,
-    SignatureType,
-    StreamMessage,
-    toStreamID
-} from '@streamr/protocol'
-import { toEthereumAddress } from '@streamr/utils'
-import { convertBytesToStreamMessage, convertStreamMessageToBytes } from '../../src/exports'
-
-describe('oldStreamMessageBinaryUtils', () => {
-    it('convertStreamMessageToBytes and convertBytesToStreamMessage', () => {
-        const streamMessage = new StreamMessage({
-            messageId: new MessageID(
-                toStreamID('test.ens/foobar'),
-                0,
-                10001,
-                0,
-                toEthereumAddress('0x1234567890123456789012345678901234567890'),
-                'msgChainId'
-            ),
-            prevMsgRef: new MessageRef(10000, 1),
-            content: new Uint8Array([1, 2, 3]),
-            contentType: ContentType.BINARY,
-            encryptionType: EncryptionType.NONE,
-            groupKeyId: '0x1234567890123456789012345678901234567890',
-            signatureType: SignatureType.SECP256K1,
-            signature: new Uint8Array([7, 8, 9])
-        })
-
-        const bytes = convertStreamMessageToBytes(streamMessage)
-        expect(bytes).toBeInstanceOf(Uint8Array)
-        expect(bytes.length).toBeGreaterThan(100)
-        const convertedStreamMessage = convertBytesToStreamMessage(bytes)
-        expect(convertedStreamMessage).toEqual(streamMessage)
-    })
-})