fix all

__tests__/QrCodeDataService.test.ts

@@ -5,10 +5,9 @@ import Utils, {
   base64ToArrayBuffer,
   arrayBufferToBase64,
 } from "../src/utils/common";
-import { MessageData } from "../src";
+import { MessageData, DocumentData, IpfsContentData } from "../src";
 
 const emailData: MessageData = {
-  statusId: "123",
   sender: {
     name: "Arty",
     email: "arty@mail.ru",
@@ -42,118 +41,230 @@ const emailData: MessageData = {
   senderPublicKeyUuid: "<uuid>",
 };
 
+const documentData: DocumentData = {
+  author: "Craig McCracken",
+  documentTitle: "The_Powerpuff_Girls",
+  documentDescription: "cartoon for kids",
+  creationDate: new Date().toDateString(),
+  documentPages: 10,
+};
+
 /**
  * Algorithm spec
  * https://code.vereign.com/internal/product/-/issues/70#note_56356
  */
 describe("QrCodeDataService", () => {
-  it("performs the whole QR code data breakage/assembling routine", async () => {
-    /**
-     * Encode
-     */
-    const encodedEmailData = QrCodeDataService.encodeEmailData(emailData);
-    const compressedEmailData = Utils.compressData(encodedEmailData);
-    const {
-      data,
-      iv: sessionIv,
-      key: sessionKey,
-    } = await CryptoService.encryptAESGCM(
-      arrayBufferToBase64(compressedEmailData)
-    );
-
-    // 32 is a head bytes size. It's the minimum, and the bigger is better.
-    // Increase it as long as you can maintain good appearance of the QR code
-    const { head, tail } = QrCodeDataService.breakQrCodeData(data, 32);
-
-    const encodedSessionKey = QrCodeDataService.encodeKeyDataPair({
-      key: arrayBufferToBase64(sessionKey),
-      data: arrayBufferToBase64(sessionIv),
-    });
+  describe("Email", () => {
+    it("performs the whole QR code data breakage/assembling routine", async () => {
+      /**
+       * Encode
+       */
+      const encodedEmailData = QrCodeDataService.encodeEmailData(emailData);
+      const compressedEmailData = Utils.compressData(encodedEmailData);
+      const {
+        data,
+        iv: sessionIv,
+        key: sessionKey,
+      } = await CryptoService.encryptAESGCM(
+        arrayBufferToBase64(compressedEmailData)
+      );
+
+      // 32 is a head bytes size. It's the minimum, and the bigger is better.
+      // Increase it as long as you can maintain good appearance of the QR code
+      const { head, tail } = QrCodeDataService.breakQrCodeData(data, 32);
+
+      const encodedSessionKey = QrCodeDataService.encodeKeyDataPair({
+        key: arrayBufferToBase64(sessionKey),
+        data: arrayBufferToBase64(sessionIv),
+      });
+
+      // In client apps, RSA encryption happens using HSM service.
+      const { privateKeyPEM, publicKeyPEM } =
+        await CryptoService.generateRSAKeys();
+
+      const encryptedSessionKey = await CryptoService.encryptRSA(
+        publicKeyPEM,
+        base64ToArrayBuffer(encodedSessionKey)
+      );
+
+      const {
+        data: doubleEncryptedSessionKey,
+        iv: storageIv,
+        key: storageKey,
+      } = await CryptoService.encryptAESGCM(
+        arrayBufferToBase64(encryptedSessionKey)
+      );
+
+      // Put base64 of this into QR code data as `?q=` param
+      const encodedStorageKeyAndHead = QrCodeDataService.encodeKeyDataPair({
+        key: arrayBufferToBase64(storageKey),
+        data: arrayBufferToBase64(head),
+      });
+
+      const encodedDoubleEncryptedSessionKey =
+        QrCodeDataService.encodeKeyDataPair({
+          key: arrayBufferToBase64(doubleEncryptedSessionKey),
+          data: arrayBufferToBase64(storageIv),
+        });
 
-    // In client apps, RSA encryption happens using HSM service.
-    const {
-      privateKeyPEM,
-      publicKeyPEM,
-    } = await CryptoService.generateRSAKeys();
-
-    const encryptedSessionKey = await CryptoService.encryptRSA(
-      publicKeyPEM,
-      base64ToArrayBuffer(encodedSessionKey)
-    );
-
-    const {
-      data: doubleEncryptedSessionKey,
-      iv: storageIv,
-      key: storageKey,
-    } = await CryptoService.encryptAESGCM(
-      arrayBufferToBase64(encryptedSessionKey)
-    );
-
-    // Put base64 of this into QR code data as `?q=` param
-    const encodedStorageKeyAndHead = QrCodeDataService.encodeKeyDataPair({
-      key: arrayBufferToBase64(storageKey),
-      data: arrayBufferToBase64(head),
+      // Send this to putQRCodeData api
+      const backblazeData = {
+        sessionKey: encodedDoubleEncryptedSessionKey,
+        tail: arrayBufferToBase64(tail),
+      };
+
+      /**
+       * Decode
+       */
+
+      // Retrieve base64 of this from QR code URL
+      const decodedStorageKeyAndHead = QrCodeDataService.decodeKeyDataPair(
+        encodedStorageKeyAndHead
+      );
+
+      // decode this from backblaze data
+      const { key: doubleEncryptedSessionKeyDecoded, data: storageIvDecoded } =
+        QrCodeDataService.decodeKeyDataPair(backblazeData.sessionKey);
+
+      const doubleDecryptedSessionKey = await CryptoService.decryptAESGCM(
+        base64ToArrayBuffer(doubleEncryptedSessionKeyDecoded),
+        base64ToArrayBuffer(decodedStorageKeyAndHead.key),
+        base64ToArrayBuffer(storageIvDecoded)
+      );
+
+      // In client apps, RSA decryption happens using HSM service.
+      const decryptedSessionKey = await CryptoService.decryptRSA(
+        privateKeyPEM,
+        base64ToArrayBuffer(doubleDecryptedSessionKey)
+      );
+
+      const decodedSessionKey =
+        QrCodeDataService.decodeKeyDataPair(decryptedSessionKey);
+
+      const assembledData = QrCodeDataService.assembleQrCodeData(
+        base64ToArrayBuffer(decodedStorageKeyAndHead.data),
+        base64ToArrayBuffer(backblazeData.tail)
+      );
+
+      const decryptedEmailData = await CryptoService.decryptAESGCM(
+        assembledData,
+        base64ToArrayBuffer(decodedSessionKey.key),
+        base64ToArrayBuffer(decodedSessionKey.data)
+      );
+
+      const decompressedEmailData = Utils.decompressData(decryptedEmailData);
+      const decodedEmailData = QrCodeDataService.decodeEmailData(
+        decompressedEmailData
+      );
+      expect(decodedEmailData).toEqual(emailData);
     });
+  });
 
-    const encodedDoubleEncryptedSessionKey = QrCodeDataService.encodeKeyDataPair(
-      {
-        key: arrayBufferToBase64(doubleEncryptedSessionKey),
-        data: arrayBufferToBase64(storageIv),
-      }
-    );
-
-    // Send this to putQRCodeData api
-    const backblazeData = {
-      sessionKey: encodedDoubleEncryptedSessionKey,
-      tail: arrayBufferToBase64(tail),
-    };
-
-    /**
-     * Decode
-     */
-
-    // Retrieve base64 of this from QR code URL
-    const decodedStorageKeyAndHead = QrCodeDataService.decodeKeyDataPair(
-      encodedStorageKeyAndHead
-    );
-
-    // decode this from backblaze data
-    const {
-      key: doubleEncryptedSessionKeyDecoded,
-      data: storageIvDecoded,
-    } = QrCodeDataService.decodeKeyDataPair(backblazeData.sessionKey);
-
-    const doubleDecryptedSessionKey = await CryptoService.decryptAESGCM(
-      base64ToArrayBuffer(doubleEncryptedSessionKeyDecoded),
-      base64ToArrayBuffer(decodedStorageKeyAndHead.key),
-      base64ToArrayBuffer(storageIvDecoded)
-    );
-
-    // In client apps, RSA decryption happens using HSM service.
-    const decryptedSessionKey = await CryptoService.decryptRSA(
-      privateKeyPEM,
-      base64ToArrayBuffer(doubleDecryptedSessionKey)
-    );
-
-    const decodedSessionKey = QrCodeDataService.decodeKeyDataPair(
-      decryptedSessionKey
-    );
-
-    const assembledData = QrCodeDataService.assembleQrCodeData(
-      base64ToArrayBuffer(decodedStorageKeyAndHead.data),
-      base64ToArrayBuffer(backblazeData.tail)
-    );
-
-    const decryptedEmailData = await CryptoService.decryptAESGCM(
-      assembledData,
-      base64ToArrayBuffer(decodedSessionKey.key),
-      base64ToArrayBuffer(decodedSessionKey.data)
-    );
-
-    const decompressedEmailData = Utils.decompressData(decryptedEmailData);
-    const decodedEmailData = QrCodeDataService.decodeEmailData(
-      decompressedEmailData
-    );
-    expect(decodedEmailData).toEqual(emailData);
+  describe("Documents", () => {
+    it("performs the whole QR code data breakage/assembling routine ", async () => {
+      /**
+       * Encode
+       */
+      const encodedDocumentData =
+        QrCodeDataService.encodeDocumentData(documentData);
+      const compressedDocumentData = Utils.compressData(encodedDocumentData);
+      const {
+        data,
+        iv: sessionIv,
+        key: sessionKey,
+      } = await CryptoService.encryptAESGCM(
+        arrayBufferToBase64(compressedDocumentData)
+      );
+
+      const { head, tail } = QrCodeDataService.breakQrCodeData(data, 32);
+
+      const encodedSessionKey = QrCodeDataService.encodeKeyDataPair({
+        key: arrayBufferToBase64(sessionKey),
+        data: arrayBufferToBase64(sessionIv),
+      });
+
+      // In client apps, RSA encryption happens using HSM service.
+      const { privateKeyPEM, publicKeyPEM } =
+        await CryptoService.generateRSAKeys();
+
+      const encryptedSessionKey = await CryptoService.encryptRSA(
+        publicKeyPEM,
+        base64ToArrayBuffer(encodedSessionKey)
+      );
+
+      const {
+        data: doubleEncryptedSessionKey,
+        iv: storageIv,
+        key: storageKey,
+      } = await CryptoService.encryptAESGCM(
+        arrayBufferToBase64(encryptedSessionKey)
+      );
+
+      // Put base64 of this into QR code data as `?q=` param
+      const encodedStorageKeyAndHead = QrCodeDataService.encodeKeyDataPair({
+        key: arrayBufferToBase64(storageKey),
+        data: arrayBufferToBase64(head),
+      });
+
+      const encodedDoubleEncryptedSessionKey =
+        QrCodeDataService.encodeKeyDataPair({
+          key: arrayBufferToBase64(doubleEncryptedSessionKey),
+          data: arrayBufferToBase64(storageIv),
+        });
+
+      // Send this to putQRCodeData api
+      const backblazeData = {
+        sessionKey: encodedDoubleEncryptedSessionKey,
+        tail: arrayBufferToBase64(tail),
+      };
+
+      /**
+       * Decode Document
+       */
+
+      // Retrieve base64 of this from QR code URL
+      const decodedStorageKeyAndHead = QrCodeDataService.decodeKeyDataPair(
+        encodedStorageKeyAndHead
+      );
+
+      // decode this from backblaze data
+      const { key: doubleEncryptedSessionKeyDecoded, data: storageIvDecoded } =
+        QrCodeDataService.decodeKeyDataPair(backblazeData.sessionKey);
+
+      const doubleDecryptedSessionKey = await CryptoService.decryptAESGCM(
+        base64ToArrayBuffer(doubleEncryptedSessionKeyDecoded),
+        base64ToArrayBuffer(decodedStorageKeyAndHead.key),
+        base64ToArrayBuffer(storageIvDecoded)
+      );
+
+      // In client apps, RSA decryption happens using HSM service.
+      const decryptedSessionKey = await CryptoService.decryptRSA(
+        privateKeyPEM,
+        base64ToArrayBuffer(doubleDecryptedSessionKey)
+      );
+
+      const decodedSessionKey =
+        QrCodeDataService.decodeKeyDataPair(decryptedSessionKey);
+
+      const assembledData = QrCodeDataService.assembleQrCodeData(
+        base64ToArrayBuffer(decodedStorageKeyAndHead.data),
+        base64ToArrayBuffer(backblazeData.tail)
+      );
+
+      const decryptedDocumentData = await CryptoService.decryptAESGCM(
+        assembledData,
+        base64ToArrayBuffer(decodedSessionKey.key),
+        base64ToArrayBuffer(decodedSessionKey.data)
+      );
+
+      const decompressedDocumentData = Utils.decompressData(
+        decryptedDocumentData
+      );
+      const decodedDocumentData = QrCodeDataService.decodeDocumentData(
+        decompressedDocumentData
+      );
+
+      expect(decodedDocumentData).toEqual(documentData);
+    });
   });
 });

dist/generated/statuses_pb.js

@@ -1765,6 +1765,225 @@ $root.vereign = (function () {
             };
             return WrapperData;
         })();
+        statuses.DocumentStatusObject = (function () {
+            /**
+             * Properties of a DocumentStatusObject.
+             * @memberof vereign.statuses
+             * @interface IDocumentStatusObject
+             * @property {number|Long|null} [timestamp] DocumentStatusObject timestamp
+             * @property {Uint8Array|null} [sealHash] DocumentStatusObject sealHash
+             */
+            /**
+             * Constructs a new DocumentStatusObject.
+             * @memberof vereign.statuses
+             * @classdesc Represents a DocumentStatusObject.
+             * @implements IDocumentStatusObject
+             * @constructor
+             * @param {vereign.statuses.IDocumentStatusObject=} [properties] Properties to set
+             */
+            function DocumentStatusObject(properties) {
+                if (properties)
+                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+            /**
+             * DocumentStatusObject timestamp.
+             * @member {number|Long} timestamp
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @instance
+             */
+            DocumentStatusObject.prototype.timestamp = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
+            /**
+             * DocumentStatusObject sealHash.
+             * @member {Uint8Array} sealHash
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @instance
+             */
+            DocumentStatusObject.prototype.sealHash = $util.newBuffer([]);
+            /**
+             * Creates a new DocumentStatusObject instance using the specified properties.
+             * @function create
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {vereign.statuses.IDocumentStatusObject=} [properties] Properties to set
+             * @returns {vereign.statuses.DocumentStatusObject} DocumentStatusObject instance
+             */
+            DocumentStatusObject.create = function create(properties) {
+                return new DocumentStatusObject(properties);
+            };
+            /**
+             * Encodes the specified DocumentStatusObject message. Does not implicitly {@link vereign.statuses.DocumentStatusObject.verify|verify} messages.
+             * @function encode
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {vereign.statuses.IDocumentStatusObject} message DocumentStatusObject message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            DocumentStatusObject.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.timestamp != null && Object.hasOwnProperty.call(message, "timestamp"))
+                    writer.uint32(/* id 1, wireType 0 =*/ 8).int64(message.timestamp);
+                if (message.sealHash != null && Object.hasOwnProperty.call(message, "sealHash"))
+                    writer.uint32(/* id 2, wireType 2 =*/ 18).bytes(message.sealHash);
+                return writer;
+            };
+            /**
+             * Encodes the specified DocumentStatusObject message, length delimited. Does not implicitly {@link vereign.statuses.DocumentStatusObject.verify|verify} messages.
+             * @function encodeDelimited
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {vereign.statuses.IDocumentStatusObject} message DocumentStatusObject message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            DocumentStatusObject.encodeDelimited = function encodeDelimited(message, writer) {
+                return this.encode(message, writer).ldelim();
+            };
+            /**
+             * Decodes a DocumentStatusObject message from the specified reader or buffer.
+             * @function decode
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {vereign.statuses.DocumentStatusObject} DocumentStatusObject
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            DocumentStatusObject.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.vereign.statuses.DocumentStatusObject();
+                while (reader.pos < end) {
+                    var tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 1:
+                            message.timestamp = reader.int64();
+                            break;
+                        case 2:
+                            message.sealHash = reader.bytes();
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                    }
+                }
+                return message;
+            };
+            /**
+             * Decodes a DocumentStatusObject message from the specified reader or buffer, length delimited.
+             * @function decodeDelimited
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @returns {vereign.statuses.DocumentStatusObject} DocumentStatusObject
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            DocumentStatusObject.decodeDelimited = function decodeDelimited(reader) {
+                if (!(reader instanceof $Reader))
+                    reader = new $Reader(reader);
+                return this.decode(reader, reader.uint32());
+            };
+            /**
+             * Verifies a DocumentStatusObject message.
+             * @function verify
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            DocumentStatusObject.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.timestamp != null && message.hasOwnProperty("timestamp"))
+                    if (!$util.isInteger(message.timestamp) && !(message.timestamp && $util.isInteger(message.timestamp.low) && $util.isInteger(message.timestamp.high)))
+                        return "timestamp: integer|Long expected";
+                if (message.sealHash != null && message.hasOwnProperty("sealHash"))
+                    if (!(message.sealHash && typeof message.sealHash.length === "number" || $util.isString(message.sealHash)))
+                        return "sealHash: buffer expected";
+                return null;
+            };
+            /**
+             * Creates a DocumentStatusObject message from a plain object. Also converts values to their respective internal types.
+             * @function fromObject
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {Object.<string,*>} object Plain object
+             * @returns {vereign.statuses.DocumentStatusObject} DocumentStatusObject
+             */
+            DocumentStatusObject.fromObject = function fromObject(object) {
+                if (object instanceof $root.vereign.statuses.DocumentStatusObject)
+                    return object;
+                var message = new $root.vereign.statuses.DocumentStatusObject();
+                if (object.timestamp != null)
+                    if ($util.Long)
+                        (message.timestamp = $util.Long.fromValue(object.timestamp)).unsigned = false;
+                    else if (typeof object.timestamp === "string")
+                        message.timestamp = parseInt(object.timestamp, 10);
+                    else if (typeof object.timestamp === "number")
+                        message.timestamp = object.timestamp;
+                    else if (typeof object.timestamp === "object")
+                        message.timestamp = new $util.LongBits(object.timestamp.low >>> 0, object.timestamp.high >>> 0).toNumber();
+                if (object.sealHash != null)
+                    if (typeof object.sealHash === "string")
+                        $util.base64.decode(object.sealHash, message.sealHash = $util.newBuffer($util.base64.length(object.sealHash)), 0);
+                    else if (object.sealHash.length)
+                        message.sealHash = object.sealHash;
+                return message;
+            };
+            /**
+             * Creates a plain object from a DocumentStatusObject message. Also converts values to other types if specified.
+             * @function toObject
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @static
+             * @param {vereign.statuses.DocumentStatusObject} message DocumentStatusObject
+             * @param {$protobuf.IConversionOptions} [options] Conversion options
+             * @returns {Object.<string,*>} Plain object
+             */
+            DocumentStatusObject.toObject = function toObject(message, options) {
+                if (!options)
+                    options = {};
+                var object = {};
+                if (options.defaults) {
+                    if ($util.Long) {
+                        var long = new $util.Long(0, 0, false);
+                        object.timestamp = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                    }
+                    else
+                        object.timestamp = options.longs === String ? "0" : 0;
+                    if (options.bytes === String)
+                        object.sealHash = "";
+                    else {
+                        object.sealHash = [];
+                        if (options.bytes !== Array)
+                            object.sealHash = $util.newBuffer(object.sealHash);
+                    }
+                }
+                if (message.timestamp != null && message.hasOwnProperty("timestamp"))
+                    if (typeof message.timestamp === "number")
+                        object.timestamp = options.longs === String ? String(message.timestamp) : message.timestamp;
+                    else
+                        object.timestamp = options.longs === String ? $util.Long.prototype.toString.call(message.timestamp) : options.longs === Number ? new $util.LongBits(message.timestamp.low >>> 0, message.timestamp.high >>> 0).toNumber() : message.timestamp;
+                if (message.sealHash != null && message.hasOwnProperty("sealHash"))
+                    object.sealHash = options.bytes === String ? $util.base64.encode(message.sealHash, 0, message.sealHash.length) : options.bytes === Array ? Array.prototype.slice.call(message.sealHash) : message.sealHash;
+                return object;
+            };
+            /**
+             * Converts this DocumentStatusObject to JSON.
+             * @function toJSON
+             * @memberof vereign.statuses.DocumentStatusObject
+             * @instance
+             * @returns {Object.<string,*>} JSON object
+             */
+            DocumentStatusObject.prototype.toJSON = function toJSON() {
+                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+            };
+            return DocumentStatusObject;
+        })();
         return statuses;
     })();
     return vereign;

dist/services/QrCodeDataService.d.ts

-import { KeyDataPair, MessageData } from "../types";
+import { KeyDataPair, MessageData, DocumentData } from "../types";
 declare const _default: {
+    encodeDocumentData: (documentData: DocumentData) => string;
+    decodeDocumentData: (binary: string | ArrayBuffer | Uint8Array) => DocumentData;
     encodeEmailData: (emailData: MessageData) => string;
     decodeEmailData: (binary: string | ArrayBuffer | Uint8Array) => MessageData;
     encodeKeyDataPair: (keyData: KeyDataPair) => string;

dist/services/QrCodeDataService.js

@@ -12,10 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const qrcode_data_pb_1 = require("../generated/qrcode_data_pb");
 const common_1 = require("../utils/common");
 const index_1 = require("../index");
+const DocumentDataMessageV1 = qrcode_data_pb_1.vereign.protobuf.qrcode_data.DocumentData_V1;
 const EmailDataMessageV1 = qrcode_data_pb_1.vereign.protobuf.qrcode_data.EmailData_V1;
 const KeyDataMessageV1 = qrcode_data_pb_1.vereign.protobuf.qrcode_data.KeyData_V1;
 const WrapperDataMessage = qrcode_data_pb_1.vereign.protobuf.qrcode_data.WrapperData;
 const EMAIL_DATA_V1 = "EmailData_V1";
+const DOCUMENT_DATA_V1 = "DocumentData_V1";
 const encodeEmailData = (emailData) => {
     const emailDataMessage = EmailDataMessageV1.fromObject(emailData);
     const emailDataBuffer = EmailDataMessageV1.encode(emailDataMessage).finish();
@@ -83,7 +85,35 @@ const verifyQrCodeSignature = (publicKey, qrCodeSignature, recipientQRCodeHash)
     const result = yield index_1.CryptoService.verifyRSASignature(publicKey, recipientQRCodeHashAsBuffer, qrCodeSignatureAsBuffer);
     return result;
 });
+const decodeDocumentData = (binary) => {
+    const wrappedDataMessage = WrapperDataMessage.decode((0, common_1.ensureUint8Array)(binary));
+    const wrappedData = WrapperDataMessage.toObject(wrappedDataMessage);
+    if (wrappedData.className === DOCUMENT_DATA_V1) {
+        const documentDataMessage = DocumentDataMessageV1.decode((0, common_1.ensureUint8Array)(wrappedData.data));
+        const messageData = DocumentDataMessageV1.toObject(documentDataMessage, {
+            bytes: String,
+            arrays: true,
+            objects: true, // populates empty objects (map fields) even if defaults=false
+        });
+        return messageData;
+    }
+    return null;
+};
+const encodeDocumentData = (documentData) => {
+    const documentDataMessage = DocumentDataMessageV1.fromObject(documentData);
+    const documentDataBuffer = DocumentDataMessageV1.encode(documentDataMessage).finish();
+    const wrappedData = {
+        version: 1,
+        className: DOCUMENT_DATA_V1,
+        data: documentDataBuffer,
+    };
+    const wrappedDataMessage = WrapperDataMessage.fromObject(wrappedData);
+    const wrappedDataBuffer = WrapperDataMessage.encode(wrappedDataMessage).finish();
+    return (0, common_1.arrayBufferToBase64)(wrappedDataBuffer);
+};
 exports.default = {
+    encodeDocumentData,
+    decodeDocumentData,
     encodeEmailData,
     decodeEmailData,
     encodeKeyDataPair,

dist/types.d.ts

@@ -135,3 +135,15 @@ export interface KeyDataPair {
     key: string;
     data: string;
 }
+export interface DocumentData {
+    author: string;
+    documentTitle: string;
+    documentDescription: string;
+    creationDate: string;
+    documentPages: number;
+    ipfs: IpfsContentData;
+}
+export interface DocumentStatusObject {
+    timestamp: number;
+    sealHash: string;
+}

src/services/QrCodeDataService.ts

-import { KeyDataPair, MessageData } from "../types";
+import { KeyDataPair, MessageData, DocumentData } from "../types";
 import { vereign } from "../generated/qrcode_data_pb";
 
 import {
@@ -9,11 +9,13 @@ import {
 
 import { CryptoService } from "../index";
 
+const DocumentDataMessageV1 = vereign.protobuf.qrcode_data.DocumentData_V1;
 const EmailDataMessageV1 = vereign.protobuf.qrcode_data.EmailData_V1;
 const KeyDataMessageV1 = vereign.protobuf.qrcode_data.KeyData_V1;
 const WrapperDataMessage = vereign.protobuf.qrcode_data.WrapperData;
 
 const EMAIL_DATA_V1 = "EmailData_V1";
+const DOCUMENT_DATA_V1 = "DocumentData_V1";
 
 interface WrappedData {
   version: number;
@@ -133,7 +135,53 @@ const verifyQrCodeSignature = async (
   return result;
 };
 
+const decodeDocumentData = (
+  binary: string | Uint8Array | ArrayBuffer
+): DocumentData => {
+  const wrappedDataMessage = WrapperDataMessage.decode(
+    ensureUint8Array(binary)
+  );
+  const wrappedData = WrapperDataMessage.toObject(
+    wrappedDataMessage
+  ) as WrappedData;
+
+  if (wrappedData.className === DOCUMENT_DATA_V1) {
+    const documentDataMessage = DocumentDataMessageV1.decode(
+      ensureUint8Array(wrappedData.data)
+    );
+
+    const messageData = DocumentDataMessageV1.toObject(documentDataMessage, {
+      bytes: String,
+      arrays: true, // populates empty arrays (repeated fields) even if defaults=false
+      objects: true, // populates empty objects (map fields) even if defaults=false
+    }) as DocumentData;
+
+    return messageData;
+  }
+
+  return null;
+};
+
+const encodeDocumentData = (documentData: DocumentData): string => {
+  const documentDataMessage = DocumentDataMessageV1.fromObject(documentData);
+  const documentDataBuffer =
+    DocumentDataMessageV1.encode(documentDataMessage).finish();
+
+  const wrappedData = {
+    version: 1,
+    className: DOCUMENT_DATA_V1,
+    data: documentDataBuffer,
+  };
+
+  const wrappedDataMessage = WrapperDataMessage.fromObject(wrappedData);
+  const wrappedDataBuffer =
+    WrapperDataMessage.encode(wrappedDataMessage).finish();
+  return arrayBufferToBase64(wrappedDataBuffer);
+};
+
 export default {
+  encodeDocumentData,
+  decodeDocumentData,
   encodeEmailData,
   decodeEmailData,
   encodeKeyDataPair,

src/types.ts

@@ -152,3 +152,23 @@ export interface KeyDataPair {
   key: string;
   data: string;
 }
+
+export interface DocumentData {
+  author: string;
+  documentTitle: string;
+  documentDescription: string;
+  creationDate: string;
+  documentPages: number;
+  ipfs: IpfsContentData;
+  // head of document //after ipfs impl
+  // cid of tail of document
+  // key
+  // Add the two below for UX optimization
+  // png of the first page
+  // sign  info
+}
+
+export interface DocumentStatusObject {
+  timestamp: number;
+  sealHash: string;
+}

vereign/protobuf/qrcode_data.proto

@@ -64,3 +64,12 @@ message WrapperData {
   int32 version = 2;
   string className = 3;
 }
+
+message DocumentData_V1 {
+  string author = 1;
+  string documentTitle = 2;
+  string documentDescription = 3;
+  string creationDate = 4;
+  int32 documentPages = 5;
+  IpfsData_V1 ipfs = 6;
+}