@freesignal/protocol 0.3.0 → 0.4.0

package/{double-ratchet.d.ts → dist/double-ratchet.d.ts}

@@ -16,8 +16,6 @@
  * 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;
     rootKey?: string;
@@ -25,6 +23,14 @@ export interface ExportedKeySession {
     receivingChain?: ExportedKeyChain;
     previousKeys: [string, Uint8Array][];
 }
+export interface EncryptionKeys {
+    readonly count: number;
+    readonly previous: number;
+    readonly publicKey: Uint8Array;
+}
+export interface PrivateEncryptionKeys extends EncryptionKeys {
+    readonly secretKey: Uint8Array;
+}
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
@@ -33,36 +39,22 @@ export declare class KeySession {
     static readonly keyLength = 32;
     static readonly version = 1;
     static readonly info: string;
+    static readonly maxCount = 65536;
     readonly id: string;
-    private readonly mutex;
-    private readonly storage;
     private keyPair;
     private rootKey?;
     private sendingChain?;
     private receivingChain?;
     private previousKeys;
-    constructor(storage: LocalStorage<string, ExportedKeySession>, opts?: {
+    constructor(opts?: {
         id?: string;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
         rootKey?: Uint8Array;
     });
     private getChain;
-    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): 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): Promise<Uint8Array>;
+    getSendingKey(): PrivateEncryptionKeys | undefined;
+    getReceivingKey(encryptionKeys: EncryptionKeys): Uint8Array | undefined;
     /**
      * Whether both the sending and receiving chains are initialized.
      */
@@ -81,7 +73,7 @@ export declare class KeySession {
      * @param json string returned by `export()` method.
      * @returns session with the state parsed.
      */
-    static from(data: ExportedKeySession, storage: LocalStorage<string, ExportedKeySession>): KeySession;
+    static from(data: ExportedKeySession): KeySession;
 }
 interface ExportedKeyChain {
     publicKey: string;
@@ -90,32 +82,4 @@ interface ExportedKeyChain {
     count: number;
     previousCount: number;
 }
-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;
-    };
-}
 export {};

package/dist/double-ratchet.js

@@ -0,0 +1,167 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeySession = void 0;
+const crypto_1 = __importDefault(require("@freesignal/crypto"));
+const utils_1 = require("@freesignal/utils");
+/**
+ * Represents a secure Double Ratchet session.
+ * Used for forward-secure encryption and decryption of messages.
+ */
+class KeySession {
+    constructor(opts = {}) {
+        var _a;
+        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;
+        if (opts.remoteKey) {
+            this.sendingChain = this.getChain(opts.remoteKey);
+        }
+    }
+    getChain(remoteKey, previousCount) {
+        const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, remoteKey);
+        if (!this.rootKey)
+            this.rootKey = crypto_1.default.hash(sharedKey);
+        const hashkey = crypto_1.default.hkdf(sharedKey, this.rootKey, KeySession.info, KeySession.keyLength * 2);
+        this.rootKey = hashkey.subarray(0, KeySession.keyLength);
+        return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength), previousCount);
+    }
+    getSendingKey() {
+        if (!this.sendingChain)
+            return;
+        const secretKey = this.sendingChain.getKey();
+        return {
+            //version: KeySession.version,
+            count: this.sendingChain.count,
+            previous: this.sendingChain.previousCount,
+            publicKey: this.sendingChain.publicKey,
+            secretKey
+        };
+    }
+    getReceivingKey(encryptionKeys) {
+        var _a, _b, _c;
+        if (!this.previousKeys.has((0, utils_1.decodeBase64)(encryptionKeys.publicKey) + encryptionKeys.count.toString())) {
+            if (!(0, utils_1.compareBytes)(encryptionKeys.publicKey, (_b = (_a = this.receivingChain) === null || _a === void 0 ? void 0 : _a.remoteKey) !== null && _b !== void 0 ? _b : new Uint8Array())) {
+                while (this.receivingChain && this.receivingChain.count < encryptionKeys.previous) {
+                    const key = this.receivingChain.getKey();
+                    this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
+                }
+                this.receivingChain = this.getChain(encryptionKeys.publicKey);
+                this.keyPair = crypto_1.default.ECDH.keyPair();
+                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_c = this.sendingChain) === null || _c === void 0 ? void 0 : _c.count);
+            }
+            if (!this.receivingChain)
+                throw new Error("Error initializing receivingChain");
+            while (this.receivingChain.count < encryptionKeys.count) {
+                const key = this.receivingChain.getKey();
+                this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
+            }
+        }
+        return this.previousKeys.get((0, utils_1.decodeBase64)(encryptionKeys.publicKey) + encryptionKeys.count.toString());
+    }
+    /**
+     * Whether both the sending and receiving chains are initialized.
+     */
+    get handshaked() { return this.sendingChain && this.receivingChain ? true : false; }
+    /**
+     * The public key of this session.
+     */
+    get publicKey() { return this.keyPair.publicKey; }
+    /**
+     * Export the state of the session;
+     */
+    toJSON() {
+        var _a, _b;
+        return {
+            secretKey: (0, utils_1.decodeBase64)(this.keyPair.secretKey),
+            rootKey: this.rootKey ? (0, utils_1.decodeBase64)(this.rootKey) : undefined,
+            sendingChain: (_a = this.sendingChain) === null || _a === void 0 ? void 0 : _a.toJSON(),
+            receivingChain: (_b = this.receivingChain) === null || _b === void 0 ? void 0 : _b.toJSON(),
+            previousKeys: Array.from(this.previousKeys.entries())
+        };
+    }
+    /**
+     * Import a state.
+     *
+     * @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: data.rootKey ? (0, utils_1.encodeBase64)(data.rootKey) : undefined });
+        session.sendingChain = data.sendingChain ? KeyChain.from(data.sendingChain) : undefined;
+        session.receivingChain = data.receivingChain ? KeyChain.from(data.receivingChain) : undefined;
+        session.previousKeys = new KeyMap(data.previousKeys);
+        return session;
+    }
+}
+exports.KeySession = KeySession;
+KeySession.keyLength = 32;
+KeySession.version = 1;
+KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
+KeySession.maxCount = 65536;
+class KeyChain {
+    constructor(publicKey, remoteKey, chainKey, previousCount = 0) {
+        this.publicKey = publicKey;
+        this.remoteKey = remoteKey;
+        this.chainKey = chainKey;
+        this.previousCount = previousCount;
+        this._count = 0;
+    }
+    getKey() {
+        if (++this._count >= KeySession.maxCount)
+            throw new Error("SendingChain count too big");
+        const hash = crypto_1.default.hkdf(this.chainKey, new Uint8Array(KeySession.keyLength).fill(0), KeySession.info, KeySession.keyLength * 2);
+        this.chainKey = hash.subarray(0, KeySession.keyLength);
+        return hash.subarray(KeySession.keyLength);
+    }
+    toString() {
+        return "[object KeyChain]";
+    }
+    get count() {
+        return this._count;
+    }
+    toJSON() {
+        return {
+            publicKey: (0, utils_1.decodeBase64)(this.publicKey),
+            remoteKey: (0, utils_1.decodeBase64)(this.remoteKey),
+            chainKey: (0, utils_1.decodeBase64)(this.chainKey),
+            count: this.count,
+            previousCount: this.previousCount
+        };
+    }
+    static from(obj) {
+        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), obj.previousCount);
+        chain._count = obj.count;
+        return chain;
+    }
+}
+class KeyMap extends Map {
+    get(key) {
+        const out = super.get(key);
+        if (out && !super.delete(key))
+            throw new Error();
+        return out;
+    }
+}

package/{index.d.ts → dist/index.d.ts}

@@ -16,7 +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, Crypto, Database } from "@freesignal/interfaces";
+import { LocalStorage, Crypto, Database, KeyExchangeDataBundle } from "@freesignal/interfaces";
 import { ExportedKeySession } from "./double-ratchet";
 import { IdentityKey, PrivateIdentityKey } from "./types";
 import { FreeSignalNode } from "./node";
@@ -47,5 +47,6 @@ export declare function createNode(storage: Database<{
     sessions: LocalStorage<string, ExportedKeySession>;
     keyExchange: LocalStorage<string, Crypto.KeyPair>;
     users: LocalStorage<string, IdentityKey>;
+    bundles: LocalStorage<string, KeyExchangeDataBundle>;
 }>, privateIdentityKey?: PrivateIdentityKey): FreeSignalNode;
 export * from "./types";

package/dist/node.d.ts

@@ -0,0 +1,71 @@
+/**
+ * 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 { 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";
+declare class BootstrapRequest {
+    #private;
+    readonly senderId: UserId | string;
+    readonly data: KeyExchangeData;
+    private readonly acceptFn;
+    constructor(senderId: UserId | string, data: KeyExchangeData, acceptFn: (data: KeyExchangeData) => Promise<Datagram>);
+    get status(): "pending" | "accepted" | "denied";
+    accept(): Promise<Datagram | undefined>;
+    deny(): void;
+}
+type OpenFnReturns = Uint8Array | UserId | Datagram | UserId | KeyExchangeData | undefined | void;
+export declare class FreeSignalNode {
+    protected readonly privateIdentityKey: PrivateIdentityKey;
+    protected readonly sessions: SessionMap;
+    protected readonly users: LocalStorage<string, IdentityKey>;
+    protected readonly bundles: LocalStorage<string, KeyExchangeDataBundle>;
+    protected readonly keyExchange: KeyExchange;
+    protected readonly discovers: Set<string>;
+    protected readonly bootstraps: Set<BootstrapRequest>;
+    constructor(storage: Database<{
+        sessions: LocalStorage<string, ExportedKeySession>;
+        keyExchange: LocalStorage<string, Crypto.KeyPair>;
+        users: LocalStorage<string, IdentityKey>;
+        bundles: LocalStorage<string, KeyExchangeDataBundle>;
+    }>, privateIdentityKey?: PrivateIdentityKey);
+    get identityKey(): IdentityKey;
+    get userId(): UserId;
+    get requests(): BootstrapRequest[];
+    protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
+    packHandshake(data: KeyExchangeData): Promise<Datagram>;
+    packData<T>(receiverId: string | UserId, data: T): Promise<Datagram>;
+    packRelay(receiverId: string | UserId, data: Datagram): Promise<Datagram>;
+    packDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<Datagram>;
+    packBootstrap(receiverId: string | UserId): Promise<Datagram>;
+    protected decrypt(datagram: Datagram): Promise<Uint8Array>;
+    open<T extends OpenFnReturns>(datagram: Datagram | Uint8Array): Promise<T>;
+}
+declare class SessionMap implements LocalStorage<string, KeySession> {
+    readonly storage: LocalStorage<string, ExportedKeySession>;
+    readonly maxSize: number;
+    private readonly cache;
+    constructor(storage: LocalStorage<string, ExportedKeySession>, maxSize?: number);
+    set(key: string, value: KeySession): Promise<void>;
+    get(key: string): Promise<KeySession | undefined>;
+    has(key: string): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+}
+export {};

package/dist/node.js

@@ -0,0 +1,261 @@
+"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) {
+        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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _BootstrapRequest_status;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeSignalNode = void 0;
+const types_1 = require("./types");
+const x3dh_1 = require("./x3dh");
+const double_ratchet_1 = require("./double-ratchet");
+const _1 = require(".");
+const utils_1 = require("@freesignal/utils");
+class BootstrapRequest {
+    constructor(senderId, data, acceptFn) {
+        this.senderId = senderId;
+        this.data = data;
+        this.acceptFn = acceptFn;
+        _BootstrapRequest_status.set(this, 'pending');
+    }
+    get status() {
+        return __classPrivateFieldGet(this, _BootstrapRequest_status, "f");
+    }
+    accept() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.status === 'pending')
+                __classPrivateFieldSet(this, _BootstrapRequest_status, 'accepted', "f");
+            if (__classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted')
+                return yield this.acceptFn(this.data);
+        });
+    }
+    deny() {
+        if (this.status === 'pending')
+            __classPrivateFieldSet(this, _BootstrapRequest_status, 'denied', "f");
+        return;
+    }
+}
+_BootstrapRequest_status = new WeakMap();
+class FreeSignalNode {
+    constructor(storage, privateIdentityKey) {
+        this.discovers = new Set();
+        this.bootstraps = new Set();
+        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
+        this.sessions = new SessionMap(storage.sessions);
+        this.keyExchange = new x3dh_1.KeyExchange(storage.keyExchange, this.privateIdentityKey);
+        this.users = storage.users;
+        this.bundles = storage.bundles;
+    }
+    get identityKey() {
+        return this.privateIdentityKey.identityKey;
+    }
+    get userId() {
+        return types_1.UserId.fromKey(this.identityKey);
+    }
+    get requests() {
+        return Array.from(this.bootstraps.values());
+    }
+    encrypt(receiverId, protocol, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (receiverId instanceof types_1.UserId)
+                receiverId = receiverId.toString();
+            const session = yield this.sessions.get(receiverId);
+            if (!session)
+                throw new Error("Session not found for user: " + receiverId);
+            const encrypted = (0, types_1.encryptData)(session, data);
+            this.sessions.set(receiverId, session);
+            return new types_1.Datagram(this.userId.toString(), receiverId, protocol, encrypted).sign(this.privateIdentityKey.signatureKey);
+        });
+    }
+    packHandshake(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { session, message, identityKey } = yield this.keyExchange.digestData(data, (0, utils_1.encodeData)(yield this.keyExchange.generateBundle()));
+            const remoteId = types_1.UserId.fromKey(identityKey);
+            yield this.users.set(remoteId.toString(), identityKey);
+            yield 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)).sign(this.privateIdentityKey.signatureKey);
+        });
+    }
+    packData(receiverId, data) {
+        return this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
+    }
+    packRelay(receiverId, data) {
+        return this.encrypt(receiverId, types_1.Protocols.RELAY, (0, utils_1.encodeData)(data));
+    }
+    packDiscover(receiverId, discoverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (receiverId instanceof types_1.UserId)
+                receiverId = receiverId.toString();
+            if (discoverId instanceof types_1.UserId)
+                discoverId = discoverId.toString();
+            const message = {
+                type: types_1.DiscoverType.REQUEST,
+                discoverId
+            };
+            this.discovers.add(receiverId);
+            return this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(message));
+        });
+    }
+    packBootstrap(receiverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
+        });
+    }
+    decrypt(datagram) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signatureKey = yield this.users.get(datagram.sender);
+            if (!signatureKey)
+                throw new Error("User IdentityKey not found");
+            if (!types_1.Datagram.verify(datagram, signatureKey.signatureKey))
+                throw new Error("Signature not verified");
+            const session = yield this.sessions.get(datagram.sender);
+            if (!session)
+                throw new Error("Session not found for user: " + datagram.sender);
+            if (!datagram.payload)
+                throw new Error("Missing payload");
+            const decrypted = (0, types_1.decryptData)(session, datagram.payload);
+            this.sessions.set(datagram.sender, session);
+            return decrypted;
+        });
+    }
+    open(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);
+                    if (!types_1.Datagram.verify(datagram, types_1.IdentityKey.from(data.identityKey).signatureKey))
+                        throw new Error("Signature not verified");
+                    const { session, identityKey, associatedData } = yield this.keyExchange.digestMessage(data);
+                    const userId = types_1.UserId.fromKey(identityKey);
+                    yield this.users.set(userId.toString(), identityKey);
+                    yield this.sessions.set(userId.toString(), session);
+                    yield this.bundles.set(userId.toString(), (0, utils_1.decodeData)(associatedData));
+                    return;
+                case types_1.Protocols.MESSAGE:
+                    return (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                case types_1.Protocols.RELAY:
+                    return (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                case types_1.Protocols.DISCOVER:
+                    const message = (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                    if (message.type === types_1.DiscoverType.REQUEST && message.discoverId && !(yield this.users.has(message.discoverId))) {
+                        let data;
+                        if (message.discoverId === this.userId.toString()) {
+                            data = yield this.keyExchange.generateData();
+                        }
+                        else {
+                            const bundle = yield this.bundles.get(message.discoverId);
+                            if (!bundle)
+                                return;
+                            const { version, identityKey, signedPreKey, signature } = bundle;
+                            const onetimePreKey = bundle.onetimePreKeys.shift();
+                            if (!onetimePreKey) {
+                                yield this.bundles.delete(message.discoverId);
+                                return;
+                            }
+                            data = {
+                                version,
+                                identityKey,
+                                signedPreKey,
+                                signature,
+                                onetimePreKey
+                            };
+                        }
+                        const response = { type: types_1.DiscoverType.RESPONSE, discoverId: message.discoverId, data };
+                        return yield this.encrypt(datagram.sender, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response));
+                    }
+                    else if (message.type === types_1.DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
+                        this.discovers.delete(message.discoverId);
+                        return message.data;
+                    }
+                    return;
+                case types_1.Protocols.BOOTSTRAP:
+                    if (datagram.payload) {
+                        const data = (0, utils_1.decodeData)(datagram.payload);
+                        if (!(0, utils_1.compareBytes)(types_1.UserId.fromKey(data.identityKey).toBytes(), (0, utils_1.encodeBase64)(datagram.sender)))
+                            return;
+                        this.bootstraps.add(new BootstrapRequest(datagram.sender, data, (data) => this.packHandshake(data)));
+                    }
+                    ;
+                    return;
+                default:
+                    throw new Error("Invalid protocol");
+            }
+        });
+    }
+}
+exports.FreeSignalNode = FreeSignalNode;
+class SessionMap {
+    constructor(storage, maxSize = 50) {
+        this.storage = storage;
+        this.maxSize = maxSize;
+        this.cache = new Map();
+    }
+    set(key, value) {
+        this.cache.set(key, value);
+        return this.storage.set(key, value.toJSON());
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.cache.get(key);
+            if (!session) {
+                const sessionData = yield this.storage.get(key);
+                if (!sessionData)
+                    return undefined;
+                return double_ratchet_1.KeySession.from(sessionData);
+            }
+            return session;
+        });
+    }
+    has(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cache.has(key) || (yield this.storage.has(key));
+        });
+    }
+    delete(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.cache.delete(key) || (yield this.storage.delete(key));
+        });
+    }
+    clear() {
+        this.cache.clear();
+        return this.storage.clear();
+    }
+}

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,41 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@freesignal/utils");
+const _1 = require(".");
+const crypto_1 = __importDefault(require("@freesignal/crypto"));
+console.log("FreeSignal protocol test");
+const bob = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap() });
+const alice = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap() });
+setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
+    const bobBootstrap = yield bob.packBootstrap(alice.userId);
+    yield alice.open(bobBootstrap);
+    const bootstraps = yield Promise.all(alice.requests.map(request => request.accept()));
+    const aliceHandshake = bootstraps.filter(value => (value === null || value === void 0 ? void 0 : value.receiver) === bob.userId.toString())[0];
+    if (!aliceHandshake)
+        throw new Error("Bootstrap Failed");
+    yield bob.open(aliceHandshake);
+    const first = (yield bob.packData(alice.userId, "Hi Alice!")).toBytes();
+    console.log("Bob: ", yield alice.open(first));
+    const second = yield alice.packData(bob.userId, "Hi Bob!");
+    console.log("Alice: ", yield bob.open(second));
+    const third = yield Promise.all(["How are you?", "How are this days?", "For me it's a good time"].map(msg => bob.packData(alice.userId, msg)));
+    third.forEach((data) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log("Bob: ", yield alice.open(data));
+    }));
+    const fourth = yield alice.packData(bob.userId, "Not so bad my man");
+    console.log("Alice: ", yield bob.open(fourth));
+    const testone = yield Promise.all(Array(400).fill(0).map(() => alice.packData(bob.userId, (0, utils_1.decodeBase64)(crypto_1.default.randomBytes(64)))));
+    console.log((yield bob.open(testone[350])));
+}));