@freesignal/protocol 0.2.9 → 0.3.0

package/index.js

@@ -17,17 +17,29 @@
  * 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;
+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.
  *
@@ -37,33 +49,34 @@ 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);
-}
+/*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 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);
-}
+/*export function createKeyExchange(storage: { keys: LocalStorage<string, Crypto.KeyPair>, sessions: LocalStorage<string, ExportedKeySession> }, privateIdentityKey?: PrivateIdentityKey): KeyExchange {
+    return new 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);
+}
+/** */
+function createNode(storage, privateIdentityKey) {
+    return new node_1.FreeSignalNode(storage, privateIdentityKey);
 }
-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,38 @@
+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: SessionMap;
+    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>;
+}
+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/node.js

@@ -0,0 +1,139 @@
+"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 double_ratchet_1 = require("./double-ratchet");
+const _1 = require(".");
+const utils_1 = require("@freesignal/utils");
+class FreeSignalNode {
+    constructor(storage, privateIdentityKey) {
+        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
+        this.sessions = new SessionMap(storage.sessions);
+        this.keyExchange = new x3dh_1.KeyExchange({ keys: storage.keyExchange, sessions: storage.sessions }, this.privateIdentityKey);
+        this.users = storage.users;
+    }
+    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 = yield 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 = yield 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;
+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, this.storage);
+            }
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -12,13 +12,9 @@
   },
   "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",
+    "semaphore.ts": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^24.2.1"

package/test.js

@@ -1,30 +1,28 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
-const _1 = require(".");
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const utils_1 = require("@freesignal/utils");
-const bob = (0, _1.createKeyExchange)(crypto_1.default.EdDSA.keyPair().secretKey, crypto_1.default.ECDH.keyPair().secretKey);
-const alice = (0, _1.createKeyExchange)(crypto_1.default.EdDSA.keyPair().secretKey, crypto_1.default.ECDH.keyPair().secretKey);
-const bobmessage = bob.generateData();
-const { session: alicesession, message: aliceack } = alice.digestData(bobmessage);
-bob.digestMessage(aliceack).then(({ session: bobsession, identityKeys }) => {
-    var _a;
-    if (bobsession && identityKeys) {
-        console.log("Session established successfully between Alice and Bob.");
-        const datagram = _1.Datagram.create(bob.signatureKey, alice.signatureKey, _1.Protocols.MESSAGE, (_a = bobsession.encrypt((0, utils_1.encodeUTF8)("Hi Alice!"))) === null || _a === void 0 ? void 0 : _a.encode());
-        //console.log(datagram.payload);
-        const msg = datagram.encode();
-        console.log((0, utils_1.decodeUTF8)(alicesession.decrypt(_1.Datagram.from(msg).payload)));
-        if (alicesession.handshaked && bobsession.handshaked)
-            console.log("Successfully handshaked");
-        else
-            console.log("Error during handshake");
-        const longmsg = _1.Datagram.create(alice.signatureKey, bob.signatureKey, _1.Protocols.MESSAGE, alicesession.encrypt(new Uint8Array(1000000).fill(33).map(val => val + Math.floor(Math.random() * 93))));
-        console.log(longmsg.encode().length);
-    }
-    else
-        console.log("Error");
-});
+const _1 = require(".");
+const bob = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap() });
+const alice = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap() });
+setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
+    const aliceHandshake = yield alice.sendHandshake(yield bob.generateKeyData());
+    yield bob.receive(aliceHandshake);
+    console.log("Session established successfully between Alice and Bob.");
+    const first = (yield bob.sendData(alice.userId.toString(), (0, utils_1.encodeData)("Hi Alice!"))).toBytes();
+    console.log("Bob: ", (0, utils_1.decodeData)(yield alice.receive(first)));
+    const second = yield alice.sendData(bob.userId.toString(), (0, utils_1.encodeData)("Hi Bob!"));
+    console.log("Alice: ", (0, utils_1.decodeData)(yield bob.receive(second)));
+    const third = yield Promise.all(["How are you?", "How are this days?", "For me it's a good time"].map(msg => bob.sendData(alice.userId.toString(), (0, utils_1.encodeData)(msg))));
+    third.forEach((value) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log("Bob: ", (0, utils_1.decodeData)(yield alice.receive(value)));
+    }));
+}));

package/types.d.ts

@@ -16,43 +16,47 @@
  * 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 { Encodable } from "@freesignal/interfaces";
-export type UserId = string;
-export declare namespace UserId {
-    class UserIdConstructor {
-        private readonly array;
-        constructor(array: Uint8Array);
-        toString(): string;
-        toJSON(): string;
-        toUint8Array(): Uint8Array;
-    }
-    export function getUserId(publicKey: string | Uint8Array): UserIdConstructor;
-    export function from(userId: string | Uint8Array): UserIdConstructor;
-    export {};
+import { LocalStorage, Encodable } from "@freesignal/interfaces";
+export declare class UserId {
+    private readonly array;
+    private constructor();
+    toString(): string;
+    toJSON(): string;
+    toUint8Array(): Uint8Array;
+    static fromKey(identityKey: string | Uint8Array | IdentityKey): UserId;
+    static from(userId: string | Uint8Array | UserId): UserId;
+}
+export interface IdentityKey extends Encodable {
+    readonly info: number;
+    readonly signatureKey: Uint8Array;
+    readonly exchangeKey: Uint8Array;
+}
+export declare namespace IdentityKey {
+    const keyLength: number;
+    const version = 1;
+    function isIdentityKeys(obj: any): boolean;
+    function from(identityKey: IdentityKey | Uint8Array | string): IdentityKey;
+    function from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): IdentityKey;
 }
-export interface IdentityKeys {
-    readonly publicKey: string;
-    readonly identityKey: string;
+export interface PrivateIdentityKey {
+    readonly info: number;
+    readonly signatureKey: Uint8Array;
+    readonly exchangeKey: Uint8Array;
+    readonly identityKey: IdentityKey;
 }
-export declare namespace IdentityKeys {
-    export const keyLength: number;
-    class IdentityKeysConstructor implements IdentityKeys, Encodable {
-        readonly publicKey: string;
-        readonly identityKey: string;
-        constructor(identityKeys: IdentityKeys | Uint8Array | string);
-        encode(): Uint8Array;
-        toString(): string;
-        toJSON(): string;
-    }
-    export function isIdentityKeys(obj: any): boolean;
-    export function from(identityKeys: IdentityKeys): IdentityKeysConstructor;
-    export {};
+export declare namespace PrivateIdentityKey {
+    const keyLength: number;
+    const version = 1;
+    function isIdentityKeys(obj: any): boolean;
+    function from(identityKey: PrivateIdentityKey | Uint8Array | string): PrivateIdentityKey;
+    function from(signatureKey: Uint8Array | string, exchangeKey: Uint8Array | string): PrivateIdentityKey;
 }
 export declare enum Protocols {
     NULL = "",
     MESSAGE = "/freesignal/message",
     RELAY = "/freesignal/relay",
-    HANDSHAKE = "/freesignal/handshake"
+    HANDSHAKE = "/freesignal/handshake",
+    DISCOVER = "/freesignal/discover"
 }
 export declare namespace Protocols {
     function isProtocol(protocol: any): boolean;
@@ -61,44 +65,31 @@ export declare namespace Protocols {
     function encode(protocol: Protocols, length?: number): Uint8Array;
     function decode(array: Uint8Array): Protocols;
 }
-export interface Datagram {
-    readonly id: string;
-    readonly version: number;
+export declare class Datagram implements Encodable {
+    static version: number;
+    private _id;
+    private _version;
     readonly sender: string;
     readonly receiver: string;
     readonly protocol: Protocols;
-    readonly createdAt: number;
-    payload?: Uint8Array;
-    readonly signature?: string;
-}
-export declare namespace Datagram {
-    export const version = 1;
-    class DatagramConstructor implements Encodable, Datagram {
-        readonly id: string;
-        readonly version: number;
-        readonly sender: UserId;
-        readonly receiver: UserId;
-        readonly protocol: Protocols;
-        readonly createdAt: number;
-        _payload?: Uint8Array;
-        _signature?: Uint8Array;
-        private secretKey?;
-        private static headerOffset;
-        constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
-        constructor(data: Uint8Array | Datagram);
-        get signed(): boolean;
-        get signature(): string | undefined;
-        set payload(data: Uint8Array);
-        get payload(): Uint8Array | undefined;
-        encode(): Uint8Array;
-        sign(secretKey: Uint8Array): this;
-        toString(): string;
-        toJSON(): string;
-    }
-    export function create(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable): DatagramConstructor;
-    export function isDatagram(obj: any): boolean;
-    export function from(data: Uint8Array | Datagram | string): DatagramConstructor;
-    export {};
+    private _createdAt;
+    private _payload?;
+    private _signature?;
+    private secretKey?;
+    private static headerOffset;
+    constructor(sender: Uint8Array | string, receiver: Uint8Array | string, protocol: Protocols, payload?: Uint8Array | Encodable);
+    get id(): string;
+    get version(): number;
+    get createdAt(): number;
+    get signed(): boolean;
+    get signature(): string | undefined;
+    set payload(data: Uint8Array);
+    get payload(): Uint8Array | undefined;
+    toBytes(): Uint8Array;
+    sign(secretKey: Uint8Array): this;
+    toString(): string;
+    toJSON(): string;
+    static from(data: Uint8Array | Datagram | string): Datagram;
 }
 /**
  * Interface representing an encrypted payload.
@@ -136,7 +127,7 @@ export interface EncryptedData extends Encodable {
     /**
      * Serializes the payload into a Uint8Array for transport.
      */
-    encode(): Uint8Array;
+    toBytes(): Uint8Array;
     /**
      * Returns the payload as a Base64 string.
      */
@@ -162,74 +153,13 @@ export declare class EncryptedData {
      */
     static from(array: Uint8Array | EncryptedData): EncryptedData;
 }
-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;
-    encode(): Uint8Array;
-    toString(): 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 declare class AsyncMap<K, V> implements LocalStorage<K, V> {
+    private readonly map;
+    constructor(iterable?: Iterable<readonly [K, V]>);
+    set(key: K, value: V): Promise<void>;
+    get(key: K): Promise<V | undefined>;
+    has(key: K): Promise<boolean>;
+    delete(key: K): Promise<boolean>;
+    clear(): Promise<void>;
+    entries(): ArrayIterator<[K, V]>;
 }
-export {};