Merge pull request #140 from ltonetwork/backport-updates

Message v2

Author: jasny

.travis.yml

@@ -66,7 +66,7 @@ jobs:
         provider: npm
         email: [email protected]
         api_key:
-          secure: MsWwbOSQKOXnZYcaIR/8YXuROE20smQA5BY/VbS2uHaoR+jRoTryqcXADdTD48HJcknsTn9CuN978NL2HTKC3hT0UD/a9neY0R96WpaXbxDU8WepU8KI6kTBKjzTlvlpgPvh7KQtuo+Zbzwj7zD/MFT0zQMuxdQJ6pLT2tU863M9puJEnJ4QQsV98xv5SASqe/5ZRpSMHzlsc9wccz+GTpfycmmJDnVpqm/Be8kGfFx5BgzN6DE6H4V87aH3HqTUIr8GvpX39mWBrK4RBCtFz/E2XVDaCBgi9VEEygQZHE9Us9MUV+gaIjSYMVSHkRbg98jd08mVvKK2qQ3hnEWWM3D8Tq7j7Pzg5lfQYiApNOx70Kb1tvIVoBdo4jUPilO3zryd6mminXCnZzFzVkUmSQXdpy4hWEw/4Ed/JMOQQ12um8oGl9u+EhYjDCReVh8/p5QBdhBah1D41E+VI7ejwN5dEpdyi/2MXPbc+cHfDaNVcXhSnG1iFQyUA614CQnA18Pywna12UGQyupgRAApUNwqEHT5oB9gcB9ZH7Q+uy3KcFvC+Fy2Yw6k0ygGNTp+8CCj6hirpREkfINlTLG19qOZArwr8Dkw36Mlo+WOj3v0/Lm68LcMAspT/LluaUNnkSgFU3vt4ffBaefhyKiO5ufxBDyykJMr21ho5xZAdgE=
+          secure: "AjrFCxtyHSZSimRF/vQr3up8s3oK3gEJZcaIO+KmgxQKhyqWdCU73y9VEm0rF5fd7nMMbK5C80dUNVnUqGszAxUCpbivEwYg+Ymugu2JrhkjTDvrcLbbQei+Z5EbONtGdqPy5WMhqjsFEcqwPA/Ja9Jd5wn6fyP5KWm/EFEfucs5JqA+CfV3YHE6i7tY6y7zlwksP3HAHUEcpDIjIy31z3gmqrsWL5q46EErub7+ugaPZSQYVgYF73xJzrZbqnEbQ5FLOP1oDNL/aEYSW9aOm7rIqlFDwO2XKKYar3U4hhM4C8kuaUrEvCv+bSGPH+zwiDVHxItZtONZRmPEE6alKUb1xokTzGo1vRcg9baSeiuazhUHzRfVJSekXCVkeArerBca/HDc6g9xwanp5FTg+uJ9DwWUfUVyzjjinJogKbx9vvHpJtS0WL72NkgS1ViRYCoEVOHVPJ7esJBN3FM3Q1jizMFh6mLMYylRaR2JpUk2pBGHXoP2J5mJxeVDbOjSe7SZKOPao/sNFQXkw7f/OFR0JF/n8SqTsRbrzneRZj99fZFzJfHZUNi0PsAvFpKQYw48JlhEwOFSqpKNCJcAtjF7p/HphPYnClbl2v3+pj8mpx51uhu2njsMNL5jQgNBhulIf2mMdGTZ7MggIA18y7yjKXqAJmDhoPIudHwSueI="
         on:
           tags: true
         skip_cleanup: true

interfaces.d.ts

@@ -46,7 +46,7 @@ export interface IBinary extends Uint8Array {
   hash(): IBinary;
   hmac(key: string | Uint8Array): IBinary;
   slice(start?: number, end?: number): IBinary;
-  reverse(): IBinary;
+  reverse(): this;
   toReversed(): IBinary;
 }
 
@@ -80,8 +80,21 @@ export interface IEventJSON {
   attachments?: Array<{ name: string; mediaType: string; data: string }>;
 }
 
-interface IMessageJSONBase {
+export interface IMessageMeta {
   type: string;
+  title: string;
+  description: string;
+  thumbnail?: IBinary;
+}
+
+interface IMessageJSONBase {
+  version: number;
+  meta: {
+    type: string;
+    title: string;
+    description: string;
+    thumbnail?: string;
+  };
   sender: IPublicAccount;
   recipient: string;
   timestamp: Date | string;

package.json

@@ -62,5 +62,6 @@
   },
   "engines": {
     "node": ">=16.0.0"
-  }
+  },
+  "packageManager": "[email protected]+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610"
 }

src/Binary.ts

@@ -50,7 +50,7 @@ export default class Binary extends Uint8Array implements IBinary {
     return new Binary(super.slice(start, end));
   }
 
-  reverse(): Binary {
+  reverse(): this {
     super.reverse();
     return this;
   }

src/constants.ts

@@ -17,3 +17,5 @@ export const DEFAULT_MESSAGE_TYPE = 'basic';
 export const ASSOCIATION_TYPE_DID_VERIFICATION_METHOD = 0x100;
 export const ASSOCIATION_TYPE_DID_DISABLE_CAPABILITY = 0x108;
 export const STATEMENT_TYPE_DEACTIVATE_DID = 0x120;
+
+export const MAX_THUMBNAIL_SIZE = 256 * 1024;

src/messages/Message.ts

@@ -1,4 +1,4 @@
-import { IBinary, IMessageJSON, TKeyType } from '../../interfaces';
+import { IBinary, IMessageJSON, IMessageMeta, TKeyType } from '../../interfaces';
 import Binary from '../Binary';
 import { Account, cypher } from '../accounts';
 import { concatBytes } from '@noble/hashes/utils';
@@ -10,12 +10,20 @@ import {
   bytesToByteArrayWithSize,
   longToByteArray,
   stringToByteArrayWithSize,
+  byteToByteArray,
+  booleanToBytes,
 } from '../utils/convert';
-import { DEFAULT_MESSAGE_TYPE } from '../constants';
+import { DEFAULT_MESSAGE_TYPE, MAX_THUMBNAIL_SIZE } from '../constants';
+
+const MESSAGE_V1 = 0;
+const MESSAGE_V2 = 1; // Meta data support
 
 export default class Message {
-  /** Type of the message */
-  type: string;
+  /** Version of the message */
+  version: number;
+
+  /** Extra info and details about the message */
+  meta: IMessageMeta = { type: DEFAULT_MESSAGE_TYPE, title: '', description: '' };
 
   /** Meta type of the data */
   mediaType: string;
@@ -41,8 +49,11 @@ export default class Message {
   /** Encrypted data */
   private _encryptedData?: IBinary;
 
-  constructor(data: any, mediaType?: string, type = DEFAULT_MESSAGE_TYPE) {
-    this.type = type;
+  constructor(data: any, mediaType?: string, meta: Partial<IMessageMeta> | string = {}) {
+    if (typeof meta === 'string') meta = { type: meta }; // Backwards compatibility
+
+    this.version = meta.title || meta.description || meta.thumbnail ? MESSAGE_V2 : MESSAGE_V1;
+    this.meta = { ...this.meta, ...meta };
 
     if (typeof data === 'string') {
       this.mediaType = mediaType ?? 'text/plain';
@@ -52,12 +63,15 @@ export default class Message {
       this.data = data instanceof Binary ? data : new Binary(data);
     } else {
       if (mediaType && mediaType !== 'application/json') throw new Error(`Unable to encode data as ${mediaType}`);
-
       this.mediaType = mediaType ?? 'application/json';
       this.data = new Binary(JSON.stringify(data));
     }
   }
 
+  get type(): string {
+    return this.meta.type; // Backwards compatibility
+  }
+
   get hash(): Binary {
     return this._hash ?? new Binary(this.toBinary(false)).hash();
   }
@@ -103,9 +117,7 @@ export default class Message {
     this.timestamp ??= new Date();
     this.sender = { keyType: sender.keyType, publicKey: sender.signKey.publicKey };
     this.signature = sender.sign(this.toBinary(false));
-
     this._hash = this.hash;
-
     return this;
   }
 
@@ -115,44 +127,96 @@ export default class Message {
 
   verifySignature(): boolean {
     if (!this.signature || !this.sender) throw new Error('Message is not signed');
-
     return cypher(this.sender).verifySignature(this.toBinary(false), this.signature);
   }
 
   verifyHash(): boolean {
     return this._hash === undefined || this._hash.hex === new Binary(this.toBinary(false)).hash().hex;
   }
 
-  toBinary(withSignature = true): Uint8Array {
-    if (!this.recipient) throw new Error('Recipient not set');
-    if (!this.sender || !this.timestamp || (withSignature && !this.signature)) throw new Error('Message not signed');
+  private toBinaryV1(withSignature = true): Uint8Array {
+    if (this.meta?.title || this.meta?.description || this.meta?.thumbnail) {
+      throw new Error('Meta information is not supported in v1');
+    }
 
     const data = this._encryptedData
       ? bytesToByteArrayWithSize(this._encryptedData, 'int32')
-      : concatBytes(stringToByteArrayWithSize(this.mediaType), bytesToByteArrayWithSize(this.data, 'int32'));
+      : concatBytes(stringToByteArrayWithSize(this.mediaType, 'int16'), bytesToByteArrayWithSize(this.data, 'int32'));
 
     return concatBytes(
-      stringToByteArrayWithSize(this.type),
-      Uint8Array.from([keyTypeId(this.sender.keyType)]),
+      byteToByteArray(MESSAGE_V1),
+      stringToByteArrayWithSize(this.meta.type, 'int8'),
+      byteToByteArray(keyTypeId(this.sender.keyType)),
       this.sender.publicKey,
       base58.decode(this.recipient),
-      longToByteArray(this.timestamp.getTime()),
-      Uint8Array.from([this._encryptedData ? 1 : 0]),
+      longToByteArray(this.timestamp?.getTime() || 0),
+      booleanToBytes(!!this._encryptedData),
       data,
-      withSignature ? this.signature : new Uint8Array(0),
+      withSignature && this.signature ? this.signature : new Uint8Array(0),
     );
   }
 
+  private toBinaryV2(withSignature = true): Uint8Array {
+    const data = this._encryptedData
+      ? bytesToByteArrayWithSize(this._encryptedData, 'int32')
+      : concatBytes(stringToByteArrayWithSize(this.mediaType, 'int16'), bytesToByteArrayWithSize(this.data, 'int32'));
+
+    return concatBytes(
+      byteToByteArray(MESSAGE_V2),
+      stringToByteArrayWithSize(this.meta.type, 'int8'),
+      stringToByteArrayWithSize(this.meta.title, 'int8'),
+      stringToByteArrayWithSize(this.meta.description, 'int16'),
+      bytesToByteArrayWithSize(this.meta.thumbnail || new Uint8Array(0), 'int32'),
+      byteToByteArray(keyTypeId(this.sender.keyType)),
+      this.sender.publicKey,
+      base58.decode(this.recipient),
+      longToByteArray(this.timestamp?.getTime() || 0),
+      booleanToBytes(!!this._encryptedData),
+      data,
+      withSignature && this.signature ? this.signature : new Uint8Array(0),
+    );
+  }
+
+  toBinary(withSignature = true): Uint8Array {
+    if (!this.recipient) {
+      throw new Error('Recipient not set');
+    }
+
+    if (this.meta.thumbnail?.length > MAX_THUMBNAIL_SIZE) {
+      throw new Error(`Thumbnail exceeds maximum size of ${MAX_THUMBNAIL_SIZE / 1024} KB`);
+    }
+
+    if (!this.signature && withSignature) {
+      throw new Error('Message not signed');
+    }
+
+    if (!this.sender || !this.sender.keyType) {
+      throw new Error('Sender key type is missing');
+    }
+
+    return this.version === MESSAGE_V1 ? this.toBinaryV1(withSignature) : this.toBinaryV2(withSignature);
+  }
+
   toJSON(): IMessageJSON {
     const base = {
-      type: this.type,
+      version: this.version,
+      meta: {
+        type: this.meta.type,
+        title: this.meta.title,
+        description: this.meta.description,
+        thumbnail: this.meta.thumbnail?.base64,
+      },
       sender: this.sender ? { keyType: this.sender.keyType, publicKey: this.sender.publicKey.base58 } : undefined,
       recipient: this.recipient,
       timestamp: this.timestamp,
       signature: this.signature?.base58,
       hash: this.hash.base58,
     };
 
+    if (this.version === MESSAGE_V1) {
+      (base as any).type = this.meta.type; // Backwards compatibility
+    }
+
     return this._encryptedData
       ? { ...base, encryptedData: 'base64:' + this._encryptedData?.base64 }
       : { ...base, mediaType: this.mediaType, data: 'base64:' + this.data?.base64 };
@@ -165,7 +229,19 @@ export default class Message {
   private static fromJSON(json: IMessageJSON): Message {
     const message: Message = Object.create(Message.prototype);
 
-    message.type = json.type;
+    if ('version' in json && json.version > MESSAGE_V2) {
+      throw new Error(`Message version ${json.version} not supported`);
+    }
+
+    if (!('version' in json)) {
+      message.version = MESSAGE_V1;
+      message.meta = { type: (json as any).type, title: '', description: '' }; // Backwards compatibility
+    } else {
+      message.version = json.version;
+      message.meta = { type: json.meta.type, title: json.meta.title, description: json.meta.description };
+      message.meta.thumbnail = json.meta.thumbnail ? Binary.fromBase64(json.meta.thumbnail) : undefined;
+    }
+
     message.sender = {
       keyType: json.sender.keyType,
       publicKey: Binary.fromBase58(json.sender.publicKey),
@@ -194,40 +270,82 @@ export default class Message {
 
   private static fromBinary(data: Uint8Array): Message {
     const message: Message = Object.create(Message.prototype);
+    message.meta = { type: '', title: '', description: '' };
     let offset = 0;
 
-    const typeBytes = byteArrayWithSizeToBytes(data.slice(offset));
-    message.type = new Binary(typeBytes).toString();
-    offset += typeBytes.length + 2;
+    // version
+    message.version = data[offset++];
 
+    if (message.version > MESSAGE_V2) {
+      throw new Error(`Message version ${message.version} not supported`);
+    }
+
+    // meta.type
+    const typeLength = data[offset++];
+    const typeBytes = data.slice(offset, offset + typeLength);
+    message.meta.type = new TextDecoder().decode(typeBytes);
+    offset += typeLength;
+
+    if (message.version === MESSAGE_V2) {
+      // meta.title
+      const titleLength = data[offset++];
+      const titleBytes = data.slice(offset, offset + titleLength);
+      message.meta.title = new TextDecoder().decode(titleBytes);
+      offset += titleLength;
+
+      // meta.description
+      const descriptionLength = byteArrayToLong(data.slice(offset, offset + 2));
+      offset += 2;
+      const descriptionBytes = data.slice(offset, offset + descriptionLength);
+      message.meta.description = new TextDecoder().decode(descriptionBytes);
+      offset += descriptionLength;
+
+      // meta.thumbnail
+      const thumbnailLength = byteArrayToLong(data.slice(offset, offset + 4));
+      offset += 4;
+      if (thumbnailLength > 0) {
+        message.meta.thumbnail = new Binary(data.slice(offset, offset + thumbnailLength));
+        offset += thumbnailLength;
+      }
+    }
+
+    // sender
     const senderKeyType = data[offset++];
     const senderPublicKeyLength = senderKeyType === 1 ? 32 : 33;
     const senderPublicKey = data.slice(offset, offset + senderPublicKeyLength);
     message.sender = { keyType: keyTypeFromId(senderKeyType), publicKey: new Binary(senderPublicKey) };
     offset += senderPublicKeyLength;
 
+    // recipient
     message.recipient = base58.encode(data.slice(offset, offset + 26));
     offset += 26;
 
-    message.timestamp = new Date(byteArrayToLong(data.slice(offset, offset + 8)));
+    // timestamp
+    const timestampBytes = data.slice(offset, offset + 8);
+    message.timestamp = new Date(byteArrayToLong(timestampBytes));
     offset += 8;
 
     const encrypted = data[offset++] === 1;
 
     if (encrypted) {
+      // encrypted data
       message._encryptedData = new Binary(byteArrayWithSizeToBytes(data.slice(offset), 'int32'));
       offset += message._encryptedData.length + 4;
     } else {
-      const mediaTypeBytes = byteArrayWithSizeToBytes(data.slice(offset));
-      message.mediaType = new Binary(mediaTypeBytes).toString();
+      // mediaType
+      const mediaTypeBytes = byteArrayWithSizeToBytes(data.slice(offset), 'int16');
+      message.mediaType = new TextDecoder().decode(mediaTypeBytes);
       offset += mediaTypeBytes.length + 2;
 
+      // data
       message.data = new Binary(byteArrayWithSizeToBytes(data.slice(offset), 'int32'));
       offset += message.data.length + 4;
     }
 
-    const signature = data.slice(offset);
-    if (signature.length > 0) message.signature = new Binary(signature);
+    // signature
+    if (offset < data.length) {
+      message.signature = new Binary(data.slice(offset));
+    }
 
     return message;
   }

src/utils/bytes.ts

@@ -39,6 +39,13 @@ export function int16ToBytes(value: number): Uint8Array {
   return bytes;
 }
 
+// Uses big endian
+export function int8ToBytes(value: number): Uint8Array {
+  const bytes = new Uint8Array(1);
+  bytes[0] = value & 0xff;
+  return bytes;
+}
+
 export function bytesToInt(bytes: Uint8Array): number {
   let value = 0;
   for (let i = 0; i < bytes.length; i++) {