@freesignal/protocol 0.2.8 → 0.2.11

package/double-ratchet.d.ts

@@ -16,6 +16,7 @@
  * 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 { LocalStorage } from "@freesignal/interfaces";
 import { EncryptedData } from "./types";
 export interface ExportedKeySession {
     secretKey: string;
@@ -36,6 +37,7 @@ export declare class KeySession {
     private static readonly skipLimit;
     static readonly version = 1;
     static readonly rootKeyLength: number;
+    readonly id: string;
     private keyPair;
     private _remoteKey?;
     private rootKey?;
@@ -45,7 +47,9 @@ export declare class KeySession {
     private receivingChain?;
     private receivingCount;
     private previousKeys;
-    constructor(opts?: {
+    private readonly storage;
+    constructor(storage: LocalStorage<string, ExportedKeySession>, opts?: {
+        id?: string;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
         rootKey?: Uint8Array;
@@ -66,20 +70,21 @@ export declare class KeySession {
     private ratchetKeys;
     private getSendingKey;
     private getReceivingKey;
+    private save;
     /**
      * Encrypts a message payload using the current sending chain.
      *
      * @param message - The message as a Uint8Array.
      * @returns An EncryptedPayload or undefined if encryption fails.
      */
-    encrypt(message: Uint8Array): EncryptedData;
+    encrypt(message: Uint8Array): Promise<EncryptedData>;
     /**
      * Decrypts an encrypted message.
      *
      * @param payload - The received encrypted message.
      * @returns The decrypted message as a Uint8Array, or undefined if decryption fails.
      */
-    decrypt(payload: Uint8Array | EncryptedData): Uint8Array | undefined;
+    decrypt(payload: Uint8Array | EncryptedData): Promise<Uint8Array | undefined>;
     /**
      * Export the state of the session;
      */
@@ -90,7 +95,7 @@ export declare class KeySession {
      * @param json string returned by `export()` method.
      * @returns session with the state parsed.
      */
-    static from(data: ExportedKeySession): KeySession;
+    static from(data: ExportedKeySession, storage: LocalStorage<string, ExportedKeySession>): KeySession;
     /**
      * The fixed key length (in bytes) used throughout the Double Ratchet session.
      * Typically 32 bytes (256 bits) for symmetric keys.
@@ -98,3 +103,31 @@ export declare class KeySession {
     static readonly keyLength = 32;
     private static symmetricRatchet;
 }
+export declare class EncryptedDataConstructor implements EncryptedData {
+    static readonly secretKeyLength: number;
+    static readonly publicKeyLength: number;
+    static readonly keyLength: number;
+    static readonly nonceLength: number;
+    static readonly maxCount = 65536;
+    static readonly countLength = 2;
+    private raw;
+    constructor(count: number | Uint8Array, previous: number | Uint8Array, publicKey: Uint8Array, nonce: Uint8Array, ciphertext: Uint8Array, version?: number | Uint8Array);
+    constructor(encrypted: Uint8Array | EncryptedData);
+    get length(): number;
+    get version(): number;
+    get count(): number;
+    get previous(): number;
+    get publicKey(): Uint8Array;
+    get nonce(): Uint8Array;
+    get ciphertext(): Uint8Array;
+    toBytes(): Uint8Array;
+    toString(): string;
+    toJSON(): {
+        version: number;
+        count: number;
+        previous: number;
+        publicKey: string;
+        nonce: string;
+        ciphertext: string;
+    };
+}

package/double-ratchet.js

@@ -17,11 +17,20 @@
  * 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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeySession = void 0;
+exports.EncryptedDataConstructor = exports.KeySession = void 0;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const utils_1 = require("@freesignal/utils");
 const types_1 = require("./types");
@@ -30,11 +39,13 @@ const types_1 = require("./types");
  * Used for forward-secure encryption and decryption of messages.
  */
 class KeySession {
-    constructor(opts = {}) {
+    constructor(storage, opts = {}) {
+        var _a;
         this.sendingCount = 0;
         this.previousCount = 0;
         this.receivingCount = 0;
         this.previousKeys = new KeyMap();
+        this.id = (_a = opts.id) !== null && _a !== void 0 ? _a : crypto_1.default.UUID.generate().toString();
         this.keyPair = crypto_1.default.ECDH.keyPair(opts.secretKey);
         if (opts.rootKey)
             this.rootKey = opts.rootKey;
@@ -42,6 +53,8 @@ class KeySession {
             this._remoteKey = opts.remoteKey;
             this.sendingChain = this.ratchetKeys();
         }
+        this.storage = storage;
+        this.storage.set(this.id, this.toJSON());
     }
     /**
      * Whether both the sending and receiving chains are initialized.
@@ -58,12 +71,12 @@ class KeySession {
     setRemoteKey(key) {
         this._remoteKey = key;
         this.receivingChain = this.ratchetKeys();
-        if (this.receivingCount > (types_1.EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
+        if (this.receivingCount > (EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
             this.receivingCount = 0;
         this.previousCount = this.sendingCount;
         this.keyPair = crypto_1.default.ECDH.keyPair();
         this.sendingChain = this.ratchetKeys();
-        if (this.sendingCount > (types_1.EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
+        if (this.sendingCount > (EncryptedDataConstructor.maxCount - KeySession.skipLimit * 2))
             this.sendingCount = 0;
         return this;
     }
@@ -93,6 +106,9 @@ class KeySession {
         this.receivingCount++;
         return sharedKey;
     }
+    save() {
+        return this.storage.set(this.id, this.toJSON());
+    }
     /**
      * Encrypts a message payload using the current sending chain.
      *
@@ -100,12 +116,15 @@ class KeySession {
      * @returns An EncryptedPayload or undefined if encryption fails.
      */
     encrypt(message) {
-        const key = this.getSendingKey();
-        if (this.sendingCount >= types_1.EncryptedDataConstructor.maxCount || this.previousCount >= types_1.EncryptedDataConstructor.maxCount)
-            throw new Error();
-        const nonce = crypto_1.default.randomBytes(types_1.EncryptedDataConstructor.nonceLength);
-        const ciphertext = crypto_1.default.box.encrypt(message, nonce, key);
-        return new types_1.EncryptedDataConstructor(this.sendingCount, this.previousCount, this.keyPair.publicKey, nonce, ciphertext);
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.getSendingKey();
+            if (this.sendingCount >= EncryptedDataConstructor.maxCount || this.previousCount >= EncryptedDataConstructor.maxCount)
+                throw new Error();
+            const nonce = crypto_1.default.randomBytes(EncryptedDataConstructor.nonceLength);
+            const ciphertext = crypto_1.default.box.encrypt(message, nonce, key);
+            yield this.save();
+            return new EncryptedDataConstructor(this.sendingCount, this.previousCount, this.keyPair.publicKey, nonce, ciphertext);
+        });
     }
     /**
      * Decrypts an encrypted message.
@@ -114,42 +133,42 @@ class KeySession {
      * @returns The decrypted message as a Uint8Array, or undefined if decryption fails.
      */
     decrypt(payload) {
-        var _a;
-        const encrypted = types_1.EncryptedData.from(payload);
-        const publicKey = encrypted.publicKey;
-        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());
+        return __awaiter(this, void 0, void 0, function* () {
+            const encrypted = types_1.EncryptedData.from(payload);
+            const publicKey = encrypted.publicKey;
+            if (this._remoteKey && !(0, utils_1.verifyArrays)(publicKey, this._remoteKey))
+                while (this.receivingCount < encrypted.previous)
+                    this.previousKeys.set(this.receivingCount, this.getReceivingKey());
             this.setRemoteKey(publicKey);
-        }
-        let key;
-        const count = encrypted.count;
-        if (this.receivingCount < count) {
-            let i = 0;
-            while (this.receivingCount < count - 1 && i < KeySession.skipLimit) {
-                this.previousKeys.set(this.receivingCount, this.getReceivingKey());
+            let key;
+            const count = encrypted.count;
+            if (this.receivingCount < count) {
+                let i = 0;
+                while (this.receivingCount < count - 1 && i < KeySession.skipLimit) {
+                    this.previousKeys.set(this.receivingCount, this.getReceivingKey());
+                }
+                key = this.getReceivingKey();
             }
-            key = this.getReceivingKey();
-        }
-        else {
-            key = this.previousKeys.get(count);
-        }
-        if (!key)
-            return undefined;
-        return (_a = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key)) !== null && _a !== void 0 ? _a : undefined;
+            else {
+                key = this.previousKeys.get(count);
+            }
+            if (!key)
+                return undefined;
+            yield this.save();
+            return crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key);
+        });
     }
     /**
      * Export the state of the session;
      */
     toJSON() {
+        var _a, _b, _c, _d;
         return {
             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),
-            receivingChain: (0, utils_1.decodeBase64)(this.receivingChain),
+            remoteKey: (0, utils_1.decodeBase64)((_a = this._remoteKey) !== null && _a !== void 0 ? _a : new Uint8Array()),
+            rootKey: (0, utils_1.decodeBase64)((_b = this.rootKey) !== null && _b !== void 0 ? _b : new Uint8Array()),
+            sendingChain: (0, utils_1.decodeBase64)((_c = this.sendingChain) !== null && _c !== void 0 ? _c : new Uint8Array()),
+            receivingChain: (0, utils_1.decodeBase64)((_d = this.receivingChain) !== null && _d !== void 0 ? _d : new Uint8Array()),
             sendingCount: this.sendingCount,
             receivingCount: this.receivingCount,
             previousCount: this.previousCount,
@@ -162,8 +181,8 @@ class KeySession {
      * @param json string returned by `export()` method.
      * @returns session with the state parsed.
      */
-    static from(data) {
-        const session = new KeySession({ secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: (0, utils_1.encodeBase64)(data.rootKey) });
+    static from(data, storage) {
+        const session = new KeySession(storage, { 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);
         session.receivingChain = (0, utils_1.encodeBase64)(data.receivingChain);
@@ -171,6 +190,7 @@ class KeySession {
         session.receivingCount = data.receivingCount;
         session.previousCount = data.previousCount;
         session.previousKeys = new KeyMap(data.previousKeys);
+        session.save();
         return session;
     }
     static symmetricRatchet(chain, salt, info) {
@@ -190,6 +210,80 @@ KeySession.rootKeyLength = crypto_1.default.box.keyLength;
  * Typically 32 bytes (256 bits) for symmetric keys.
  */
 KeySession.keyLength = 32;
+class EncryptedDataConstructor {
+    constructor(...arrays) {
+        arrays = arrays.filter(value => value !== undefined);
+        if (arrays[0] instanceof EncryptedDataConstructor) {
+            this.raw = arrays[0].raw;
+            return this;
+        }
+        if (typeof arrays[0] === 'number')
+            arrays[0] = (0, utils_1.numberToArray)(arrays[0], EncryptedDataConstructor.countLength);
+        if (typeof arrays[1] === 'number')
+            arrays[1] = (0, utils_1.numberToArray)(arrays[1], EncryptedDataConstructor.countLength);
+        if (arrays.length === 6) {
+            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.numberToArray)(KeySession.version));
+        }
+        this.raw = (0, utils_1.concatArrays)(...arrays);
+    }
+    get length() { return this.raw.length; }
+    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); }
+    toBytes() {
+        return this.raw;
+    }
+    toString() {
+        return (0, utils_1.decodeBase64)(this.raw);
+    }
+    toJSON() {
+        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;
+EncryptedDataConstructor.secretKeyLength = crypto_1.default.ECDH.secretKeyLength;
+EncryptedDataConstructor.publicKeyLength = crypto_1.default.ECDH.publicKeyLength;
+EncryptedDataConstructor.keyLength = crypto_1.default.box.keyLength;
+EncryptedDataConstructor.nonceLength = crypto_1.default.box.nonceLength;
+EncryptedDataConstructor.maxCount = 65536; //32768;
+EncryptedDataConstructor.countLength = 2;
+class Offsets {
+    static set(start, length) {
+        class Offset {
+            constructor(start, length) {
+                this.start = start;
+                this.length = length;
+                if (typeof length === 'number')
+                    this.end = start + length;
+            }
+            get get() {
+                return [this.start, this.length];
+            }
+        }
+        return new Offset(start, length);
+    }
+}
+Offsets.checksum = Offsets.set(0, 0);
+Offsets.version = Offsets.set(Offsets.checksum.end, 1);
+Offsets.count = Offsets.set(Offsets.version.end, EncryptedDataConstructor.countLength);
+Offsets.previous = Offsets.set(Offsets.count.end, EncryptedDataConstructor.countLength);
+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);
 class KeyMap extends Map {
     get(key) {
         const out = super.get(key);

package/index.d.ts

@@ -16,10 +16,10 @@
  * 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 from "@freesignal/crypto";
 import { LocalStorage, Crypto } from "@freesignal/interfaces";
-import { KeySession } from "./double-ratchet";
+import { ExportedKeySession, KeySession } from "./double-ratchet";
 import { KeyExchange } from "./x3dh";
+import { PrivateIdentityKey } from "./types";
 /**
  * Creates a new Double Ratchet session for secure message exchange.
  *
@@ -29,7 +29,7 @@ import { KeyExchange } from "./x3dh";
  * @param opts.rootKey - An optional root key to initialize the session.
  * @returns A new instance of {@link KeySession}.
  */
-export declare function createKeySession(opts?: {
+export declare function createKeySession(storage: LocalStorage<string, ExportedKeySession>, opts?: {
     secretKey?: Uint8Array;
     remoteKey?: Uint8Array;
     rootKey?: Uint8Array;
@@ -37,21 +37,18 @@ export declare function createKeySession(opts?: {
 /**
  * Creates a new X3DH (Extended Triple Diffie-Hellman) key exchange session.
  *
- * @param signSecretKey - The EdDSA signing secret key as a Uint8Array.
- * @param boxSecretKey - The ECDH box secret key as a Uint8Array.
- * @param bundleStore - Optional local storage for key bundles.
+ * @param storage - Local storage for keys.
  * @returns A new instance of {@link KeyExchange}.
  */
-export declare function createKeyExchange(signSecretKey: Uint8Array, boxSecretKey: Uint8Array, bundleStore?: LocalStorage<string, crypto.KeyPair>): KeyExchange;
+export declare function createKeyExchange(storage: {
+    keys: LocalStorage<string, Crypto.KeyPair>;
+    sessions: LocalStorage<string, ExportedKeySession>;
+}, privateIdentityKey?: PrivateIdentityKey): KeyExchange;
 /**
- * Generates identity key pairs for signing and encryption.
+ * Generates identity key
  *
- * @param signSecretKey - Optional secret key for EdDSA signing.
- * @param boxSecretKey - Optional secret key for ECDH encryption.
+ * @param seed - Seed to generate the key.
  * @returns An object containing readonly signing and box key pairs.
  */
-export declare function createIdentityKeys(signSecretKey?: Uint8Array, boxSecretKey?: Uint8Array): {
-    readonly sign: Crypto.KeyPair;
-    readonly box: Crypto.KeyPair;
-};
-export { UserId, IdentityKeys, Protocols, Datagram, EncryptedData } from "./types";
+export declare function createIdentity(seed?: Uint8Array): PrivateIdentityKey;
+export * from "./types";

package/index.js

@@ -17,17 +17,31 @@
  * 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncryptedData = exports.Datagram = exports.Protocols = exports.IdentityKeys = exports.UserId = void 0;
 exports.createKeySession = createKeySession;
 exports.createKeyExchange = createKeyExchange;
-exports.createIdentityKeys = createIdentityKeys;
+exports.createIdentity = createIdentity;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const double_ratchet_1 = require("./double-ratchet");
 const x3dh_1 = require("./x3dh");
+const types_1 = require("./types");
 /**
  * Creates a new Double Ratchet session for secure message exchange.
  *
@@ -37,33 +51,30 @@ const x3dh_1 = require("./x3dh");
  * @param opts.rootKey - An optional root key to initialize the session.
  * @returns A new instance of {@link KeySession}.
  */
-function createKeySession(opts) {
-    return new double_ratchet_1.KeySession(opts);
+function createKeySession(storage, opts) {
+    return new double_ratchet_1.KeySession(storage, opts);
 }
 /**
  * Creates a new X3DH (Extended Triple Diffie-Hellman) key exchange session.
  *
- * @param signSecretKey - The EdDSA signing secret key as a Uint8Array.
- * @param boxSecretKey - The ECDH box secret key as a Uint8Array.
- * @param bundleStore - Optional local storage for key bundles.
+ * @param storage - Local storage for keys.
  * @returns A new instance of {@link KeyExchange}.
  */
-function createKeyExchange(signSecretKey, boxSecretKey, bundleStore) {
-    return new x3dh_1.KeyExchange(signSecretKey, boxSecretKey, bundleStore);
+function createKeyExchange(storage, privateIdentityKey) {
+    return new x3dh_1.KeyExchange(storage, privateIdentityKey);
 }
 /**
- * Generates identity key pairs for signing and encryption.
+ * Generates identity key
  *
- * @param signSecretKey - Optional secret key for EdDSA signing.
- * @param boxSecretKey - Optional secret key for ECDH encryption.
+ * @param seed - Seed to generate the key.
  * @returns An object containing readonly signing and box key pairs.
  */
-function createIdentityKeys(signSecretKey, boxSecretKey) {
-    return { sign: crypto_1.default.EdDSA.keyPair(signSecretKey), box: crypto_1.default.ECDH.keyPair(boxSecretKey) };
+function createIdentity(seed) {
+    seed !== null && seed !== void 0 ? seed : (seed = crypto_1.default.randomBytes(crypto_1.default.EdDSA.seedLength));
+    const signatureSeed = crypto_1.default.hkdf(seed, new Uint8Array(crypto_1.default.EdDSA.seedLength).fill(0), "identity-ed25519", crypto_1.default.EdDSA.seedLength);
+    const exchangeSeed = crypto_1.default.hkdf(seed, new Uint8Array(crypto_1.default.ECDH.secretKeyLength).fill(0), "identity-x25519", crypto_1.default.ECDH.secretKeyLength);
+    const signatureKeyPair = crypto_1.default.EdDSA.keyPairFromSeed(signatureSeed);
+    const exchangeKeyPair = crypto_1.default.ECDH.keyPair(exchangeSeed);
+    return types_1.PrivateIdentityKey.from(signatureKeyPair.secretKey, exchangeKeyPair.secretKey);
 }
-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; } });
-Object.defineProperty(exports, "Protocols", { enumerable: true, get: function () { return types_1.Protocols; } });
-Object.defineProperty(exports, "Datagram", { enumerable: true, get: function () { return types_1.Datagram; } });
-Object.defineProperty(exports, "EncryptedData", { enumerable: true, get: function () { return types_1.EncryptedData; } });
+__exportStar(require("./types"), exports);

package/node.d.ts

@@ -0,0 +1,27 @@
+import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
+import { Datagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
+import { KeyExchange } from "./x3dh";
+import { ExportedKeySession, KeySession } from "./double-ratchet";
+export declare class FreeSignalNode {
+    protected readonly privateIdentityKey: PrivateIdentityKey;
+    protected readonly sessions: Map<string, KeySession>;
+    protected readonly sessionsData: LocalStorage<string, ExportedKeySession>;
+    protected readonly users: LocalStorage<string, IdentityKey>;
+    protected readonly keyExchange: KeyExchange;
+    constructor(storage: Database<{
+        sessions: LocalStorage<string, ExportedKeySession>;
+        keyExchange: LocalStorage<string, Crypto.KeyPair>;
+        users: LocalStorage<string, IdentityKey>;
+    }>, privateIdentityKey?: PrivateIdentityKey);
+    get userId(): UserId;
+    get identityKey(): IdentityKey;
+    generateKeyData(): Promise<KeyExchangeData>;
+    generateKeyBundle(length?: number): Promise<KeyExchangeDataBundle>;
+    encrypt(receiverId: string, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
+    sendHandshake(data: KeyExchangeData): Promise<Datagram>;
+    sendData<T>(receiverId: string, data: T): Promise<Datagram>;
+    sendRelay(receiverId: string, data: Datagram): Promise<Datagram>;
+    sendDiscover(receiverId: string, discoverId: string): Promise<Datagram>;
+    decrypt(datagram: Datagram): Promise<Uint8Array>;
+    receive<T extends Uint8Array | UserId | Datagram | UserId | void>(datagram: Datagram | Uint8Array): Promise<T>;
+}

package/node.js

@@ -0,0 +1,105 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeSignalNode = void 0;
+const types_1 = require("./types");
+const x3dh_1 = require("./x3dh");
+const _1 = require(".");
+const utils_1 = require("@freesignal/utils");
+class FreeSignalNode {
+    constructor(storage, privateIdentityKey) {
+        this.sessions = new Map();
+        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
+        this.sessionsData = storage.sessions;
+        this.keyExchange = new x3dh_1.KeyExchange({ keys: storage.keyExchange, sessions: storage.sessions }, this.privateIdentityKey);
+        this.users = storage.users;
+        /*Array.from(this.sessionsData.entries()).forEach(([userId, sessionData]) => {
+            this.sessions.set(userId, KeySession.from(sessionData, this.sessionsData));
+        });*/
+    }
+    get userId() {
+        return types_1.UserId.fromKey(this.privateIdentityKey.identityKey);
+    }
+    get identityKey() {
+        return this.privateIdentityKey.identityKey;
+    }
+    generateKeyData() {
+        return this.keyExchange.generateData();
+    }
+    ;
+    generateKeyBundle(length) {
+        return this.keyExchange.generateBundle(length);
+    }
+    ;
+    encrypt(receiverId, protocol, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.get(receiverId);
+            if (!session)
+                throw new Error("Session not found for user: " + receiverId);
+            return new types_1.Datagram(this.userId.toString(), receiverId, protocol, yield session.encrypt(data));
+        });
+    }
+    sendHandshake(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { session, message, identityKey } = yield this.keyExchange.digestData(data);
+            const remoteId = types_1.UserId.fromKey(identityKey);
+            this.sessions.set(remoteId.toString(), session);
+            return new types_1.Datagram(this.userId.toString(), types_1.UserId.fromKey(data.identityKey).toString(), types_1.Protocols.HANDSHAKE, (0, utils_1.encodeData)(message));
+        });
+    }
+    sendData(receiverId, data) {
+        return this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
+    }
+    sendRelay(receiverId, data) {
+        return this.encrypt(receiverId, types_1.Protocols.RELAY, (0, utils_1.encodeData)(data));
+    }
+    sendDiscover(receiverId, discoverId) {
+        return this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(discoverId));
+    }
+    decrypt(datagram) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = datagram.sender;
+            const session = this.sessions.get(userId);
+            if (!session)
+                throw new Error("Session not found for user: " + userId);
+            if (!datagram.payload)
+                throw new Error("Missing payload");
+            const decrypted = yield session.decrypt(datagram.payload);
+            if (!decrypted)
+                throw new Error("Decryption failed");
+            return decrypted;
+        });
+    }
+    receive(datagram) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (datagram instanceof Uint8Array)
+                datagram = types_1.Datagram.from(datagram);
+            switch (datagram.protocol) {
+                case types_1.Protocols.HANDSHAKE:
+                    if (!datagram.payload)
+                        throw new Error("Missing payload");
+                    const data = (0, utils_1.decodeData)(datagram.payload);
+                    const { session, identityKey } = yield this.keyExchange.digestMessage(data);
+                    this.sessions.set(types_1.UserId.fromKey(identityKey).toString(), session);
+                    return;
+                case types_1.Protocols.MESSAGE:
+                    return yield this.decrypt(datagram);
+                case types_1.Protocols.RELAY:
+                    return (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                case types_1.Protocols.DISCOVER:
+                    return types_1.UserId.from((0, utils_1.decodeData)(yield this.decrypt(datagram)));
+                default:
+                    throw new Error("Invalid protocol");
+            }
+        });
+    }
+}
+exports.FreeSignalNode = FreeSignalNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.2.8",
+  "version": "0.2.11",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -12,13 +12,8 @@
   },
   "dependencies": {
     "@freesignal/crypto": "^0.3.0",
-    "@freesignal/interfaces": "^0.1.1",
-    "@freesignal/utils": "^1.2.0",
-    "base64-js": "^1.5.1",
-    "fflate": "^0.8.2",
-    "js-sha3": "^0.9.3",
-    "tweetnacl": "^1.0.3",
-    "uuid": "^11.1.0"
+    "@freesignal/interfaces": "^0.2.0",
+    "@freesignal/utils": "^1.3.0"
   },
   "devDependencies": {
     "@types/node": "^24.2.1"