@freesignal/protocol 0.2.11 → 0.3.2

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

@@ -20,56 +20,34 @@ import { LocalStorage } from "@freesignal/interfaces";
 import { EncryptedData } from "./types";
 export interface ExportedKeySession {
     secretKey: string;
-    remoteKey: string;
-    rootKey: string;
-    sendingChain: string;
-    receivingChain: string;
-    sendingCount: number;
-    receivingCount: number;
-    previousCount: number;
-    previousKeys: [number, Uint8Array][];
+    rootKey?: string;
+    sendingChain?: ExportedKeyChain;
+    receivingChain?: ExportedKeyChain;
+    previousKeys: [string, Uint8Array][];
 }
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
  */
 export declare class KeySession {
-    private static readonly skipLimit;
+    static readonly keyLength = 32;
     static readonly version = 1;
-    static readonly rootKeyLength: number;
+    static readonly info: string;
     readonly id: string;
+    private readonly mutex;
+    private readonly storage;
     private keyPair;
-    private _remoteKey?;
     private rootKey?;
     private sendingChain?;
-    private sendingCount;
-    private previousCount;
     private receivingChain?;
-    private receivingCount;
     private previousKeys;
-    private readonly storage;
     constructor(storage: LocalStorage<string, ExportedKeySession>, opts?: {
         id?: string;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
         rootKey?: Uint8Array;
     });
-    /**
-     * Whether both the sending and receiving chains are initialized.
-     */
-    get handshaked(): boolean;
-    /**
-     * The public key of this session.
-     */
-    get publicKey(): Uint8Array;
-    /**
-     * The last known remote public key.
-     */
-    get remoteKey(): Uint8Array | undefined;
-    private setRemoteKey;
-    private ratchetKeys;
-    private getSendingKey;
-    private getReceivingKey;
+    private getChain;
     private save;
     /**
      * Encrypts a message payload using the current sending chain.
@@ -84,7 +62,15 @@ export declare class KeySession {
      * @param payload - The received encrypted message.
      * @returns The decrypted message as a Uint8Array, or undefined if decryption fails.
      */
-    decrypt(payload: Uint8Array | EncryptedData): Promise<Uint8Array | undefined>;
+    decrypt(payload: Uint8Array | EncryptedData): Promise<Uint8Array>;
+    /**
+     * Whether both the sending and receiving chains are initialized.
+     */
+    get handshaked(): boolean;
+    /**
+     * The public key of this session.
+     */
+    get publicKey(): Uint8Array;
     /**
      * Export the state of the session;
      */
@@ -96,12 +82,13 @@ export declare class KeySession {
      * @returns session with the state parsed.
      */
     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.
-     */
-    static readonly keyLength = 32;
-    private static symmetricRatchet;
+}
+interface ExportedKeyChain {
+    publicKey: string;
+    remoteKey: string;
+    chainKey: string;
+    count: number;
+    previousCount: number;
 }
 export declare class EncryptedDataConstructor implements EncryptedData {
     static readonly secretKeyLength: number;
@@ -131,3 +118,4 @@ export declare class EncryptedDataConstructor implements EncryptedData {
         ciphertext: string;
     };
 }
+export {};

package/dist/double-ratchet.js

@@ -0,0 +1,345 @@
+"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 __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedDataConstructor = exports.KeySession = void 0;
+const crypto_1 = __importDefault(require("@freesignal/crypto"));
+const utils_1 = require("@freesignal/utils");
+const types_1 = require("./types");
+const semaphore_ts_1 = require("semaphore.ts");
+/**
+ * Represents a secure Double Ratchet session.
+ * Used for forward-secure encryption and decryption of messages.
+ */
+class KeySession {
+    constructor(storage, opts = {}) {
+        var _a;
+        this.mutex = { sending: new semaphore_ts_1.AsyncMutex(), receiving: new semaphore_ts_1.AsyncMutex() };
+        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);
+        }
+        this.storage = storage;
+        this.save();
+    }
+    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);
+    }
+    save() {
+        return this.storage.set(this.id, this.toJSON());
+    }
+    /**
+     * 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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const lock = __addDisposableResource(env_1, yield this.mutex.sending.acquire(), false);
+                if (!this.sendingChain)
+                    throw new Error("SendingChain not initialized");
+                const key = this.sendingChain.getKey();
+                const nonce = crypto_1.default.randomBytes(EncryptedDataConstructor.nonceLength);
+                const ciphertext = crypto_1.default.box.encrypt(message, nonce, key);
+                this.save();
+                return new EncryptedDataConstructor(this.sendingChain.count, this.sendingChain.previousCount, this.keyPair.publicKey, nonce, ciphertext);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        });
+    }
+    /**
+     * Decrypts an encrypted message.
+     *
+     * @param payload - The received encrypted message.
+     * @returns The decrypted message as a Uint8Array, or undefined if decryption fails.
+     */
+    decrypt(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const encrypted = types_1.EncryptedData.from(payload);
+            if (!this.previousKeys.has((0, utils_1.decodeBase64)(encrypted.publicKey) + encrypted.count.toString())) {
+                const lock = yield this.mutex.receiving.acquire();
+                if (!(0, utils_1.compareBytes)(encrypted.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 < encrypted.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(encrypted.publicKey);
+                    this.keyPair = crypto_1.default.ECDH.keyPair();
+                    this.sendingChain = this.getChain(encrypted.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 < encrypted.count) {
+                    const key = this.receivingChain.getKey();
+                    this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
+                }
+                lock.release();
+            }
+            const key = this.previousKeys.get((0, utils_1.decodeBase64)(encrypted.publicKey) + encrypted.count.toString());
+            if (!key)
+                throw new Error("Error calculating key");
+            this.save();
+            const cleartext = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key);
+            if (!cleartext)
+                throw new Error("Error decrypting ciphertext");
+            return cleartext;
+        });
+    }
+    /**
+     * 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, storage) {
+        const session = new KeySession(storage, { secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: data.rootKey ? (0, utils_1.encodeBase64)(data.rootKey) : undefined });
+        //session._remoteKey = data.remoteKey ? encodeBase64(data.remoteKey) : 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);
+        session.save();
+        return session;
+    }
+}
+exports.KeySession = KeySession;
+KeySession.keyLength = 32;
+KeySession.version = 1;
+KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
+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 >= EncryptedDataConstructor.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 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.numberToBytes)(arrays[0], EncryptedDataConstructor.countLength);
+        if (typeof arrays[1] === 'number')
+            arrays[1] = (0, utils_1.numberToBytes)(arrays[1], EncryptedDataConstructor.countLength);
+        if (arrays.length === 6) {
+            arrays.unshift(typeof arrays[5] === 'number' ? (0, utils_1.numberToBytes)(arrays[5], 1) : arrays[5]);
+            arrays.pop();
+        }
+        else if (arrays.length > 1) {
+            arrays.unshift((0, utils_1.numberToBytes)(KeySession.version, 1));
+        }
+        this.raw = (0, utils_1.concatBytes)(...arrays);
+    }
+    get length() { return this.raw.length; }
+    get version() { return (0, utils_1.bytesToNumber)(new Uint8Array(this.raw.buffer, ...Offsets.version.get)); }
+    get count() { return (0, utils_1.bytesToNumber)(new Uint8Array(this.raw.buffer, ...Offsets.count.get)); }
+    get previous() { return (0, utils_1.bytesToNumber)(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);
+        if (out && !super.delete(key))
+            throw new Error();
+        return out;
+    }
+}

package/{index.d.ts → dist/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 { LocalStorage, Crypto } from "@freesignal/interfaces";
-import { ExportedKeySession, KeySession } from "./double-ratchet";
-import { KeyExchange } from "./x3dh";
-import { PrivateIdentityKey } from "./types";
+import { LocalStorage, Crypto, Database, KeyExchangeDataBundle } from "@freesignal/interfaces";
+import { ExportedKeySession } from "./double-ratchet";
+import { IdentityKey, PrivateIdentityKey } from "./types";
+import { FreeSignalNode } from "./node";
 /**
  * Creates a new Double Ratchet session for secure message exchange.
  *
@@ -29,21 +29,12 @@ import { PrivateIdentityKey } from "./types";
  * @param opts.rootKey - An optional root key to initialize the session.
  * @returns A new instance of {@link KeySession}.
  */
-export declare function createKeySession(storage: LocalStorage<string, ExportedKeySession>, opts?: {
-    secretKey?: Uint8Array;
-    remoteKey?: Uint8Array;
-    rootKey?: Uint8Array;
-}): KeySession;
 /**
  * Creates a new X3DH (Extended Triple Diffie-Hellman) key exchange session.
  *
  * @param storage - Local storage for keys.
  * @returns A new instance of {@link KeyExchange}.
  */
-export declare function createKeyExchange(storage: {
-    keys: LocalStorage<string, Crypto.KeyPair>;
-    sessions: LocalStorage<string, ExportedKeySession>;
-}, privateIdentityKey?: PrivateIdentityKey): KeyExchange;
 /**
  * Generates identity key
  *
@@ -51,4 +42,11 @@ export declare function createKeyExchange(storage: {
  * @returns An object containing readonly signing and box key pairs.
  */
 export declare function createIdentity(seed?: Uint8Array): PrivateIdentityKey;
+/** */
+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/{index.js → dist/index.js}

@@ -35,13 +35,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createKeySession = createKeySession;
-exports.createKeyExchange = createKeyExchange;
 exports.createIdentity = createIdentity;
+exports.createNode = createNode;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
-const double_ratchet_1 = require("./double-ratchet");
-const x3dh_1 = require("./x3dh");
 const types_1 = require("./types");
+const node_1 = require("./node");
 /**
  * Creates a new Double Ratchet session for secure message exchange.
  *
@@ -51,18 +49,18 @@ const types_1 = require("./types");
  * @param opts.rootKey - An optional root key to initialize the session.
  * @returns A new instance of {@link KeySession}.
  */
-function createKeySession(storage, opts) {
-    return new double_ratchet_1.KeySession(storage, opts);
-}
+/*export function createKeySession(storage: LocalStorage<string, ExportedKeySession>, opts?: { secretKey?: Uint8Array, remoteKey?: Uint8Array, rootKey?: Uint8Array }): KeySession {
+    return new KeySession(storage, opts);
+}*/
 /**
  * Creates a new X3DH (Extended Triple Diffie-Hellman) key exchange session.
  *
  * @param storage - Local storage for keys.
  * @returns A new instance of {@link KeyExchange}.
  */
-function createKeyExchange(storage, privateIdentityKey) {
-    return new x3dh_1.KeyExchange(storage, privateIdentityKey);
-}
+/*export function createKeyExchange(storage: { keys: LocalStorage<string, Crypto.KeyPair>, sessions: LocalStorage<string, ExportedKeySession> }, privateIdentityKey?: PrivateIdentityKey): KeyExchange {
+    return new KeyExchange(storage, privateIdentityKey);
+}*/
 /**
  * Generates identity key
  *
@@ -77,4 +75,8 @@ function createIdentity(seed) {
     const exchangeKeyPair = crypto_1.default.ECDH.keyPair(exchangeSeed);
     return types_1.PrivateIdentityKey.from(signatureKeyPair.secretKey, exchangeKeyPair.secretKey);
 }
+/** */
+function createNode(storage, privateIdentityKey) {
+    return new node_1.FreeSignalNode(storage, privateIdentityKey);
+}
 __exportStar(require("./types"), exports);

package/dist/node.d.ts

@@ -0,0 +1,53 @@
+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 {};