@freesignal/protocol 0.2.5 → 0.2.8

package/api.d.ts

@@ -1,20 +1,37 @@
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>
+ */
 import { Crypto, KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, LocalStorage } from "@freesignal/interfaces";
-import { KeySession } from "./double-ratchet";
+import { ExportedKeySession } from "./double-ratchet";
 import { KeyExchange } from "./x3dh";
 import { Datagram, IdentityKeys, EncryptedData, UserId } from "./types";
-export declare const FREESIGNAL_MIME = "application/x-freesignal";
 type DatagramId = string;
 export declare class FreeSignalAPI {
     protected readonly signKey: Crypto.KeyPair;
     protected readonly boxKey: Crypto.KeyPair;
-    protected readonly sessions: LocalStorage<UserId, KeySession>;
+    protected readonly sessions: LocalStorage<UserId, ExportedKeySession>;
     protected readonly keyExchange: KeyExchange;
     protected readonly users: LocalStorage<UserId, IdentityKeys>;
     readonly userId: UserId;
     constructor(opts: {
         secretSignKey: Uint8Array;
         secretBoxKey: Uint8Array;
-        sessions: LocalStorage<UserId, KeySession>;
+        sessions: LocalStorage<UserId, ExportedKeySession>;
         keyExchange: LocalStorage<string, Crypto.KeyPair>;
         users: LocalStorage<UserId, IdentityKeys>;
     });
@@ -33,9 +50,5 @@ export declare class FreeSignalAPI {
         identityKeys: IdentityKeys;
         userId: UserId;
     }>;
-    protected packIdList(datagramIds: DatagramId[]): Uint8Array;
-    protected unpackIdList(data: Uint8Array): DatagramId[];
-    protected packDatagrams(messages: Datagram[]): Uint8Array;
-    protected unpackDatagrams(data: Uint8Array): Datagram[];
 }
 export {};

package/api.js

@@ -1,4 +1,22 @@
 "use strict";
+/**
+ * FreeSignal Protocol
+ *
+ * Copyright (C) 2025  Christian Braghette
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>
+ */
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -12,13 +30,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreeSignalAPI = exports.FREESIGNAL_MIME = void 0;
+exports.FreeSignalAPI = void 0;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
+const double_ratchet_1 = require("./double-ratchet");
 const x3dh_1 = require("./x3dh");
 const utils_1 = require("@freesignal/utils");
 const types_1 = require("./types");
-const fflate_1 = __importDefault(require("fflate"));
-exports.FREESIGNAL_MIME = "application/x-freesignal";
 class FreeSignalAPI {
     constructor(opts) {
         const { secretSignKey, secretBoxKey, sessions, keyExchange, users } = opts;
@@ -37,23 +54,25 @@ class FreeSignalAPI {
     }
     encryptData(data, userId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const session = yield this.sessions.get(userId);
-            if (!session)
+            const sessionJson = yield this.sessions.get(userId);
+            if (!sessionJson)
                 throw new Error('Session not found for user: ' + userId);
+            const session = double_ratchet_1.KeySession.from(sessionJson);
             const encrypted = session.encrypt(data);
-            this.sessions.set(userId, session); // Ensure session is updated
+            this.sessions.set(userId, session.toJSON()); // Ensure session is updated
             return encrypted;
         });
     }
     decryptData(data, userId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const session = yield this.sessions.get(userId);
-            if (!session)
+            const sessionJson = yield this.sessions.get(userId);
+            if (!sessionJson)
                 throw new Error('Session not found for user: ' + userId);
+            const session = double_ratchet_1.KeySession.from(sessionJson);
             const decrypted = session.decrypt(data);
             if (!decrypted)
                 throw new Error('Decryption failed for user: ' + userId);
-            this.sessions.set(userId, session); // Ensure session is updated
+            this.sessions.set(userId, session.toJSON()); // Ensure session is updated
             return decrypted;
         });
     }
@@ -62,7 +81,10 @@ class FreeSignalAPI {
             const res = yield fetch(`${url}/${userId !== null && userId !== void 0 ? userId : ''}`, {
                 method: 'GET'
             });
-            return (0, utils_1.decodeJSON)(new Uint8Array(yield res.arrayBuffer()));
+            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
+            if (body.type === 'error')
+                throw new Error(body.data);
+            return body.data;
         });
     }
     postHandshake(url, message) {
@@ -70,9 +92,9 @@ class FreeSignalAPI {
             const res = yield fetch(url, {
                 method: 'POST',
                 headers: {
-                    'Content-Type': exports.FREESIGNAL_MIME
+                    'Content-Type': types_1.XFreeSignal.MIME
                 },
-                body: (0, utils_1.encodeJSON)(message)
+                body: types_1.XFreeSignal.encodeBody('data', message)
             });
             return res.status === 200;
         });
@@ -82,10 +104,10 @@ class FreeSignalAPI {
             const res = yield fetch(url, {
                 method: 'PUT',
                 headers: {
-                    'Content-Type': exports.FREESIGNAL_MIME,
+                    'Content-Type': types_1.XFreeSignal.MIME,
                     authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
                 },
-                body: (0, utils_1.encodeJSON)(bundle)
+                body: types_1.XFreeSignal.encodeBody('data', bundle)
             });
             return res.status === 201;
         });
@@ -109,35 +131,44 @@ class FreeSignalAPI {
                     authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
                 }
             });
-            return this.unpackDatagrams(yield this.decryptData(new Uint8Array(yield res.arrayBuffer()), types_1.UserId.getUserId(publicKey).toString()));
+            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
+            if (body.type === 'error')
+                throw new Error(body.data);
+            return types_1.DataEncoder.from(yield this.decryptData(body.data, types_1.UserId.getUserId(publicKey).toString())).data.map(array => types_1.Datagram.from(array));
         });
     }
     postDatagrams(datagrams, publicKey, url) {
         return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.encryptData(this.packDatagrams(datagrams), types_1.UserId.getUserId(publicKey).toString());
+            const data = yield this.encryptData(new types_1.DataEncoder(datagrams.map(datagram => types_1.Datagram.from(datagram).encode())).encode(), types_1.UserId.getUserId(publicKey).toString());
             const res = yield fetch(url, {
                 method: 'POST',
                 headers: {
-                    'Content-Type': exports.FREESIGNAL_MIME,
+                    'Content-Type': types_1.XFreeSignal.MIME,
                     authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
                 },
-                body: data.encode()
+                body: types_1.XFreeSignal.encodeBody('data', data.encode())
             });
-            return (0, utils_1.numberFromUint8Array)(yield this.decryptData(new Uint8Array(yield res.arrayBuffer()), types_1.UserId.getUserId(publicKey).toString()));
+            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
+            if (body.type === 'error')
+                throw new Error(body.data);
+            return types_1.DataEncoder.from(yield this.decryptData(body.data, types_1.UserId.getUserId(publicKey).toString())).data;
         });
     }
     deleteDatagrams(datagramIds, publicKey, url) {
         return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.encryptData(this.packIdList(datagramIds), types_1.UserId.getUserId(publicKey).toString());
+            const data = yield this.encryptData(new types_1.DataEncoder(datagramIds.map(datagramId => crypto_1.default.UUID.parse(datagramId))).encode(), types_1.UserId.getUserId(publicKey).toString());
             const res = yield fetch(url, {
                 method: 'DELETE',
                 headers: {
-                    'Content-Type': exports.FREESIGNAL_MIME,
+                    'Content-Type': types_1.XFreeSignal.MIME,
                     authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
                 },
-                body: data.encode()
+                body: types_1.XFreeSignal.encodeBody('data', data.encode())
             });
-            return (0, utils_1.numberFromUint8Array)(yield this.decryptData(new Uint8Array(yield res.arrayBuffer()), types_1.UserId.getUserId(publicKey).toString()));
+            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
+            if (body.type === 'error')
+                throw new Error(body.data);
+            return types_1.DataEncoder.from(yield this.decryptData(body.data, types_1.UserId.getUserId(publicKey).toString())).data;
         });
     }
     createToken(publicKey) {
@@ -160,47 +191,5 @@ class FreeSignalAPI {
             throw new Error('Authorization header is required');
         });
     }
-    packIdList(datagramIds) {
-        return datagramIds.map(datagramId => crypto_1.default.UUID.parse(datagramId)).reduce((prev, curr) => new Uint8Array([...prev, ...curr]), new Uint8Array());
-    }
-    unpackIdList(data) {
-        const ids = [];
-        for (let i = 0; i < data.length; i += 16) {
-            ids.push(crypto_1.default.UUID.stringify(data.subarray(i, i + 16)));
-        }
-        return ids;
-    }
-    packDatagrams(messages) {
-        return fflate_1.default.deflateSync((0, utils_1.concatUint8Array)(...messages.flatMap(datagram => {
-            const encoded = types_1.Datagram.from(datagram).encode();
-            return [(0, utils_1.numberToUint8Array)(encoded.length, 8), encoded];
-        })));
-    }
-    unpackDatagrams(data) {
-        const messages = [];
-        let offset = 0;
-        data = fflate_1.default.inflateSync(data);
-        while (offset < data.length) {
-            const length = data.subarray(offset, offset + 8);
-            if (length.length < 8) {
-                throw new Error('Invalid message length');
-            }
-            const messageLength = (0, utils_1.numberFromUint8Array)(length);
-            offset += 8;
-            if (offset + messageLength > data.length) {
-                throw new Error('Invalid message length');
-            }
-            const messageData = data.subarray(offset, offset + messageLength);
-            offset += messageLength;
-            try {
-                const datagram = types_1.Datagram.from(messageData);
-                messages.push(datagram);
-            }
-            catch (error) {
-                throw new Error('Invalid datagram format');
-            }
-        }
-        return messages;
-    }
 }
 exports.FreeSignalAPI = FreeSignalAPI;

package/double-ratchet.d.ts

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { EncryptedData } from "./types";
-type ExportedKeySession = {
+export interface ExportedKeySession {
     secretKey: string;
     remoteKey: string;
     rootKey: string;
@@ -27,7 +27,7 @@ type ExportedKeySession = {
     receivingCount: number;
     previousCount: number;
     previousKeys: [number, Uint8Array][];
-};
+}
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
@@ -90,7 +90,7 @@ export declare class KeySession {
      * @param json string returned by `export()` method.
      * @returns session with the state parsed.
      */
-    static parse(json: string): KeySession;
+    static from(data: ExportedKeySession): KeySession;
     /**
      * The fixed key length (in bytes) used throughout the Double Ratchet session.
      * Typically 32 bytes (256 bits) for symmetric keys.
@@ -98,4 +98,3 @@ export declare class KeySession {
     static readonly keyLength = 32;
     private static symmetricRatchet;
 }
-export {};

package/double-ratchet.js

@@ -117,7 +117,9 @@ class KeySession {
         var _a;
         const encrypted = types_1.EncryptedData.from(payload);
         const publicKey = encrypted.publicKey;
-        if (!(0, utils_1.verifyUint8Array)(publicKey, this._remoteKey)) {
+        if (!this._remoteKey)
+            throw new Error("Missing remoteKey");
+        if (!(0, utils_1.verifyArrays)(publicKey, this._remoteKey)) {
             while (this.receivingCount < encrypted.previous)
                 this.previousKeys.set(this.receivingCount, this.getReceivingKey());
             this.setRemoteKey(publicKey);
@@ -143,7 +145,7 @@ class KeySession {
      */
     toJSON() {
         return {
-            secretKey: (0, utils_1.decodeBase64)((0, utils_1.concatUint8Array)(this.keyPair.secretKey)),
+            secretKey: (0, utils_1.decodeBase64)((0, utils_1.concatArrays)(this.keyPair.secretKey)),
             remoteKey: (0, utils_1.decodeBase64)(this._remoteKey),
             rootKey: (0, utils_1.decodeBase64)(this.rootKey),
             sendingChain: (0, utils_1.decodeBase64)(this.sendingChain),
@@ -160,8 +162,7 @@ class KeySession {
      * @param json string returned by `export()` method.
      * @returns session with the state parsed.
      */
-    static parse(json) {
-        const data = JSON.parse(json);
+    static from(data) {
         const session = new KeySession({ secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: (0, utils_1.encodeBase64)(data.rootKey) });
         session._remoteKey = (0, utils_1.encodeBase64)(data.remoteKey);
         session.sendingChain = (0, utils_1.encodeBase64)(data.sendingChain);

package/index.js

@@ -61,15 +61,6 @@ function createKeyExchange(signSecretKey, boxSecretKey, bundleStore) {
 function createIdentityKeys(signSecretKey, boxSecretKey) {
     return { sign: crypto_1.default.EdDSA.keyPair(signSecretKey), box: crypto_1.default.ECDH.keyPair(boxSecretKey) };
 }
-/*export function createAPI(opts: {
-    secretSignKey: Uint8Array;
-    secretBoxKey: Uint8Array;
-    sessions: LocalStorage<UserId, KeySession>;
-    keyExchange: LocalStorage<string, Crypto.KeyPair>;
-    users: LocalStorage<UserId, IdentityKeys>;
-}): FreeSignalAPI {
-    return new FreeSignalAPI(opts);
-}*/
 var types_1 = require("./types");
 Object.defineProperty(exports, "UserId", { enumerable: true, get: function () { return types_1.UserId; } });
 Object.defineProperty(exports, "IdentityKeys", { enumerable: true, get: function () { return types_1.IdentityKeys; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.2.5",
+  "version": "0.2.8",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -13,7 +13,7 @@
   "dependencies": {
     "@freesignal/crypto": "^0.3.0",
     "@freesignal/interfaces": "^0.1.1",
-    "@freesignal/utils": "^1.1.0",
+    "@freesignal/utils": "^1.2.0",
     "base64-js": "^1.5.1",
     "fflate": "^0.8.2",
     "js-sha3": "^0.9.3",

package/types.d.ts

@@ -144,7 +144,14 @@ export interface EncryptedData extends Encodable {
     /**
      * Returns the decoded object as a JSON string.
      */
-    toJSON(): string;
+    toJSON(): {
+        version: number;
+        count: number;
+        previous: number;
+        publicKey: string;
+        nonce: string;
+        ciphertext: string;
+    };
 }
 export declare class EncryptedData {
     /**
@@ -174,5 +181,55 @@ export declare class EncryptedDataConstructor implements EncryptedData {
     get ciphertext(): Uint8Array;
     encode(): Uint8Array;
     toString(): string;
-    toJSON(): string;
+    toJSON(): {
+        version: number;
+        count: number;
+        previous: number;
+        publicKey: string;
+        nonce: string;
+        ciphertext: string;
+    };
 }
+declare enum DataType {
+    UKNOWN = -1,
+    RAW = 0,
+    NUMBER = 1,
+    STRING = 2,
+    ARRAY = 3,
+    OBJECT = 4
+}
+declare namespace DataType {
+    function getType(type: string): DataType;
+    function getName(type: DataType): string;
+    function from(data: any): DataType;
+}
+export declare class DataEncoder<T> implements Encodable {
+    readonly data: T;
+    readonly type: string;
+    constructor(data: T);
+    protected get _type(): DataType;
+    encode(): Uint8Array;
+    toString(): string;
+    toJSON(): T;
+    static from<T = any>(array: Uint8Array): DataEncoder<T>;
+}
+export declare namespace XFreeSignal {
+    export const MIME = "application/x-freesignal";
+    export const version = 1;
+    export function encodeBody(type: 'data' | 'error', data: any, compressed?: boolean): BodyInit;
+    export function decodeBody<T = any>(body: Uint8Array): Body<T>;
+    class Body<T> implements Encodable {
+        readonly type: 'data' | 'error';
+        readonly data: T;
+        constructor(type: 'data' | 'error', data: T);
+        encode(compressed?: boolean): Uint8Array;
+        toString(): string;
+        toJSON(): {
+            type: "data" | "error";
+            data: T;
+        };
+        static from<T = any>(array: Uint8Array): Body<T>;
+    }
+    export {};
+}
+export {};

package/types.js

@@ -21,10 +21,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncryptedDataConstructor = exports.EncryptedData = exports.Datagram = exports.Protocols = exports.IdentityKeys = exports.UserId = void 0;
+exports.XFreeSignal = exports.DataEncoder = exports.EncryptedDataConstructor = exports.EncryptedData = exports.Datagram = exports.Protocols = exports.IdentityKeys = exports.UserId = void 0;
 const utils_1 = require("@freesignal/utils");
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const double_ratchet_1 = require("./double-ratchet");
+const fflate_1 = __importDefault(require("fflate"));
 var UserId;
 (function (UserId) {
     class UserIdConstructor {
@@ -36,7 +37,7 @@ var UserId;
             return (0, utils_1.decodeBase64)(this.array);
         }
         toJSON() {
-            return JSON.stringify(this.toString());
+            return this.toString();
         }
         toUint8Array() {
             return this.array;
@@ -68,13 +69,13 @@ var IdentityKeys;
             }
         }
         encode() {
-            return (0, utils_1.concatUint8Array)((0, utils_1.encodeBase64)(this.publicKey), (0, utils_1.encodeBase64)(this.identityKey));
+            return (0, utils_1.concatArrays)((0, utils_1.encodeBase64)(this.publicKey), (0, utils_1.encodeBase64)(this.identityKey));
         }
         toString() {
             throw (0, utils_1.decodeBase64)(this.encode());
         }
         toJSON() {
-            throw JSON.stringify(this.toString());
+            throw this.toString();
         }
     }
     function isIdentityKeys(obj) {
@@ -107,11 +108,11 @@ var Protocols;
     }
     Protocols.toCode = toCode;
     function encode(protocol, length) {
-        return (0, utils_1.numberToUint8Array)(Protocols.toCode(protocol), length);
+        return (0, utils_1.numberToArray)(Protocols.toCode(protocol), length);
     }
     Protocols.encode = encode;
     function decode(array) {
-        return Protocols.fromCode((0, utils_1.numberFromUint8Array)(array));
+        return Protocols.fromCode((0, utils_1.numberFromArray)(array));
     }
     Protocols.decode = decode;
 })(Protocols || (exports.Protocols = Protocols = {}));
@@ -125,7 +126,7 @@ var Datagram;
                     this.version = data[0] & 127;
                     this.protocol = Protocols.decode(data.subarray(1, 2));
                     this.id = crypto_1.default.UUID.stringify(data.subarray(2, 18));
-                    this.createdAt = (0, utils_1.numberFromUint8Array)(data.subarray(18, 26));
+                    this.createdAt = (0, utils_1.numberFromArray)(data.subarray(18, 26));
                     this.sender = (0, utils_1.decodeBase64)(data.subarray(26, 26 + crypto_1.default.EdDSA.publicKeyLength));
                     this.receiver = (0, utils_1.decodeBase64)(data.subarray(26 + crypto_1.default.EdDSA.publicKeyLength, DatagramConstructor.headerOffset));
                     if (data[0] & 128)
@@ -177,16 +178,16 @@ var Datagram;
         }
         encode() {
             var _a, _b, _c;
-            const data = (0, utils_1.concatUint8Array)(new Uint8Array(1).fill(this.version | (this.secretKey ? 128 : 0)), //1
+            const data = (0, utils_1.concatArrays)(new Uint8Array(1).fill(this.version | (this.secretKey ? 128 : 0)), //1
             Protocols.encode(this.protocol), //1
             (_a = crypto_1.default.UUID.parse(this.id)) !== null && _a !== void 0 ? _a : [], //16
-            (0, utils_1.numberToUint8Array)(this.createdAt, 8), //8
+            (0, utils_1.numberToArray)(this.createdAt, 8), //8
             (0, utils_1.encodeBase64)(this.sender), //32
             (0, utils_1.encodeBase64)(this.receiver), //32
             (_b = this._payload) !== null && _b !== void 0 ? _b : new Uint8Array());
             if (this.secretKey)
                 this._signature = crypto_1.default.EdDSA.sign(data, this.secretKey);
-            return (0, utils_1.concatUint8Array)(data, (_c = this._signature) !== null && _c !== void 0 ? _c : new Uint8Array());
+            return (0, utils_1.concatArrays)(data, (_c = this._signature) !== null && _c !== void 0 ? _c : new Uint8Array());
         }
         sign(secretKey) {
             this.secretKey = secretKey;
@@ -196,7 +197,7 @@ var Datagram;
             return (0, utils_1.decodeBase64)(this.encode());
         }
         toJSON() {
-            return JSON.stringify(this.toString());
+            return this.toString();
         }
     }
     DatagramConstructor.headerOffset = 26 + crypto_1.default.EdDSA.publicKeyLength * 2;
@@ -238,22 +239,22 @@ class EncryptedDataConstructor {
             return this;
         }
         if (typeof arrays[0] === 'number')
-            arrays[0] = (0, utils_1.numberToUint8Array)(arrays[0], EncryptedDataConstructor.countLength);
+            arrays[0] = (0, utils_1.numberToArray)(arrays[0], EncryptedDataConstructor.countLength);
         if (typeof arrays[1] === 'number')
-            arrays[1] = (0, utils_1.numberToUint8Array)(arrays[1], EncryptedDataConstructor.countLength);
+            arrays[1] = (0, utils_1.numberToArray)(arrays[1], EncryptedDataConstructor.countLength);
         if (arrays.length === 6) {
-            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToUint8Array)(arrays[5]) : arrays[5]);
+            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToArray)(arrays[5]) : arrays[5]);
             arrays.pop();
         }
         else if (arrays.length > 1) {
-            arrays.unshift((0, utils_1.numberToUint8Array)(double_ratchet_1.KeySession.version));
+            arrays.unshift((0, utils_1.numberToArray)(double_ratchet_1.KeySession.version));
         }
-        this.raw = (0, utils_1.concatUint8Array)(...arrays);
+        this.raw = (0, utils_1.concatArrays)(...arrays);
     }
     get length() { return this.raw.length; }
-    get version() { return (0, utils_1.numberFromUint8Array)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
-    get count() { return (0, utils_1.numberFromUint8Array)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
-    get previous() { return (0, utils_1.numberFromUint8Array)(new Uint8Array(this.raw.buffer, ...Offsets.previous.get)); }
+    get version() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
+    get count() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
+    get previous() { return (0, utils_1.numberFromArray)(new Uint8Array(this.raw.buffer, ...Offsets.previous.get)); }
     get publicKey() { return new Uint8Array(this.raw.buffer, ...Offsets.publicKey.get); }
     get nonce() { return new Uint8Array(this.raw.buffer, ...Offsets.nonce.get); }
     get ciphertext() { return new Uint8Array(this.raw.buffer, Offsets.ciphertext.start); }
@@ -264,14 +265,14 @@ class EncryptedDataConstructor {
         return (0, utils_1.decodeBase64)(this.raw);
     }
     toJSON() {
-        return JSON.stringify({
+        return {
             version: this.version,
             count: this.count,
             previous: this.previous,
             publicKey: (0, utils_1.decodeBase64)(this.publicKey),
             nonce: (0, utils_1.decodeBase64)(this.nonce),
             ciphertext: (0, utils_1.decodeBase64)(this.ciphertext)
-        });
+        };
     }
 }
 exports.EncryptedDataConstructor = EncryptedDataConstructor;
@@ -304,3 +305,156 @@ Offsets.previous = Offsets.set(Offsets.count.end, EncryptedDataConstructor.count
 Offsets.publicKey = Offsets.set(Offsets.previous.end, EncryptedDataConstructor.publicKeyLength);
 Offsets.nonce = Offsets.set(Offsets.publicKey.end, EncryptedDataConstructor.nonceLength);
 Offsets.ciphertext = Offsets.set(Offsets.nonce.end, undefined);
+var DataType;
+(function (DataType) {
+    DataType[DataType["UKNOWN"] = -1] = "UKNOWN";
+    DataType[DataType["RAW"] = 0] = "RAW";
+    DataType[DataType["NUMBER"] = 1] = "NUMBER";
+    DataType[DataType["STRING"] = 2] = "STRING";
+    DataType[DataType["ARRAY"] = 3] = "ARRAY";
+    DataType[DataType["OBJECT"] = 4] = "OBJECT";
+})(DataType || (DataType = {}));
+(function (DataType) {
+    function getType(type) {
+        return Object.values(DataType).indexOf(type.toLocaleUpperCase());
+    }
+    DataType.getType = getType;
+    function getName(type) {
+        return DataType[type].toLowerCase();
+    }
+    DataType.getName = getName;
+    function from(data) {
+        if (data instanceof Uint8Array)
+            return DataType.RAW;
+        return getType(typeof data);
+    }
+    DataType.from = from;
+})(DataType || (DataType = {}));
+class DataEncoder {
+    constructor(data) {
+        this.data = data;
+        this.type = DataType.getName(DataType.from(this.data));
+    }
+    get _type() {
+        return DataType.getType(this.type);
+    }
+    encode() {
+        let data;
+        switch (this._type) {
+            case DataType.RAW:
+                data = this.data;
+                break;
+            case DataType.NUMBER:
+                data = (0, utils_1.numberToArray)(this._type);
+                break;
+            case DataType.STRING:
+                data = (0, utils_1.encodeUTF8)(this.data);
+                break;
+            case DataType.ARRAY:
+                data = (0, utils_1.concatArrays)(...Array.from(this.data).flatMap(value => {
+                    const data = new DataEncoder(value).encode();
+                    return [(0, utils_1.numberToArray)(data.length, 8), data];
+                }));
+                break;
+            case DataType.OBJECT:
+                data = (0, utils_1.encodeJSON)(this.data);
+                break;
+            default:
+                throw new Error("Uknown type");
+        }
+        return (0, utils_1.concatArrays)((0, utils_1.numberToArray)(this._type), data);
+    }
+    toString() {
+        return "[Object XFreeSignalData]";
+    }
+    toJSON() {
+        return this.data;
+    }
+    static from(array) {
+        const type = array[0];
+        let rawData = array.subarray(1), data;
+        switch (type) {
+            case DataType.RAW:
+                data = rawData;
+                break;
+            case DataType.NUMBER:
+                data = (0, utils_1.numberFromArray)(rawData);
+                break;
+            case DataType.STRING:
+                data = (0, utils_1.decodeUTF8)(rawData);
+                break;
+            case DataType.ARRAY:
+                const arrayData = [];
+                let offset = 0;
+                while (offset < rawData.length) {
+                    const length = rawData.subarray(offset, offset + 8);
+                    if (length.length < 8)
+                        throw new Error('Invalid data length');
+                    const messageLength = (0, utils_1.numberFromArray)(length);
+                    offset += 8;
+                    if (offset + messageLength > rawData.length) {
+                        throw new Error('Invalid data length');
+                    }
+                    arrayData.push(rawData.subarray(offset, offset + messageLength));
+                    offset += messageLength;
+                }
+                data = arrayData;
+                break;
+            case DataType.OBJECT:
+                data = (0, utils_1.decodeJSON)(rawData);
+                break;
+            default:
+                throw new Error('Invalid data format');
+        }
+        return new DataEncoder(data);
+    }
+}
+exports.DataEncoder = DataEncoder;
+var XFreeSignal;
+(function (XFreeSignal) {
+    XFreeSignal.MIME = "application/x-freesignal";
+    XFreeSignal.version = 1;
+    function encodeBody(type, data, compressed = false) {
+        return new Body(type, data).encode(compressed);
+    }
+    XFreeSignal.encodeBody = encodeBody;
+    function decodeBody(body) {
+        return Body.from(body);
+    }
+    XFreeSignal.decodeBody = decodeBody;
+    let BodyType;
+    (function (BodyType) {
+        BodyType[BodyType["DATA"] = 0] = "DATA";
+        BodyType[BodyType["ERROR"] = 1] = "ERROR";
+    })(BodyType || (BodyType = {}));
+    (function (BodyType) {
+        function getName(type) {
+            return BodyType[type].toLowerCase();
+        }
+        BodyType.getName = getName;
+    })(BodyType || (BodyType = {}));
+    class Body {
+        constructor(type, data) {
+            this.type = type;
+            this.data = data;
+        }
+        encode(compressed = false) {
+            const data = new DataEncoder(this.data).encode();
+            return (0, utils_1.concatArrays)((0, utils_1.numberToArray)(((this.type === 'data' ? BodyType.DATA : BodyType.ERROR) << 6)
+                + (compressed ? 32 : 0)
+                + XFreeSignal.version), compressed ? fflate_1.default.deflateSync(data) : data);
+        }
+        toString() {
+            return "[Object XFreeSignalBody]";
+        }
+        toJSON() {
+            return {
+                type: this.type,
+                data: this.data
+            };
+        }
+        static from(array) {
+            return new Body(BodyType.getName((array[0] & 64) >> 6), DataEncoder.from((array[0] & 32) >> 5 === 1 ? fflate_1.default.inflateSync(array.subarray(1)) : array.subarray(1)).data);
+        }
+    }
+})(XFreeSignal || (exports.XFreeSignal = XFreeSignal = {}));

package/x3dh.d.ts

@@ -19,6 +19,11 @@
 import { KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, LocalStorage, Crypto } from "@freesignal/interfaces";
 import { KeySession } from "./double-ratchet";
 import { IdentityKeys } from "./types";
+export interface ExportedKeyExchange {
+    signatureKey: Crypto.KeyPair;
+    identityKey: Crypto.KeyPair;
+    bundleStore: Array<[string, Crypto.KeyPair]>;
+}
 export declare class KeyExchange {
     static readonly version = 1;
     private static readonly hkdfInfo;
@@ -42,4 +47,6 @@ export declare class KeyExchange {
         session: KeySession;
         identityKeys: IdentityKeys;
     }>;
+    toJSON(): ExportedKeyExchange;
+    static from(data: ExportedKeyExchange): KeyExchange;
 }

package/x3dh.js

@@ -94,7 +94,7 @@ class KeyExchange {
             ...onetimePreKey ? crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, onetimePreKey) : new Uint8Array()
         ]), new Uint8Array(double_ratchet_1.KeySession.rootKeyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.rootKeyLength);
         const session = new double_ratchet_1.KeySession({ remoteKey: identityKey, rootKey });
-        const cyphertext = session.encrypt((0, utils_1.concatUint8Array)(crypto_1.default.hash(this._identityKey.publicKey), crypto_1.default.hash(identityKey)));
+        const cyphertext = session.encrypt((0, utils_1.concatArrays)(crypto_1.default.hash(this._identityKey.publicKey), crypto_1.default.hash(identityKey)));
         if (!cyphertext)
             throw new Error("Decryption error");
         return {
@@ -135,7 +135,7 @@ class KeyExchange {
             const cleartext = session.decrypt((0, utils_1.encodeBase64)(message.associatedData));
             if (!cleartext)
                 throw new Error("Error decrypting ACK message");
-            if (!(0, utils_1.verifyUint8Array)(cleartext, (0, utils_1.concatUint8Array)(crypto_1.default.hash(identityKey), crypto_1.default.hash(this._identityKey.publicKey))))
+            if (!(0, utils_1.verifyArrays)(cleartext, (0, utils_1.concatArrays)(crypto_1.default.hash(identityKey), crypto_1.default.hash(this._identityKey.publicKey))))
                 throw new Error("Error verifing Associated Data");
             return {
                 session,
@@ -146,19 +146,29 @@ class KeyExchange {
             };
         });
     }
+    toJSON() {
+        return {
+            identityKey: this._identityKey,
+            signatureKey: this._signatureKey,
+            bundleStore: Array.from(this.bundleStore.entries())
+        };
+    }
+    static from(data) {
+        return new KeyExchange(data.signatureKey.secretKey, data.identityKey.secretKey, new AsyncMap(data.bundleStore));
+    }
 }
 exports.KeyExchange = KeyExchange;
 KeyExchange.version = 1;
 KeyExchange.hkdfInfo = (0, utils_1.encodeUTF8)("freesignal/x3dh/" + KeyExchange.version);
 KeyExchange.maxOPK = 10;
 class AsyncMap {
-    constructor() {
-        this.map = new Map();
+    constructor(iterable) {
+        this.map = new Map(iterable);
     }
     set(key, value) {
         return __awaiter(this, void 0, void 0, function* () {
             this.map.set(key, value);
-            return this;
+            return;
         });
     }
     get(key) {
@@ -177,8 +187,6 @@ class AsyncMap {
         });
     }
     entries() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.entries();
-        });
+        return this.map.entries();
     }
 }