@freesignal/protocol 0.3.0 → 0.4.0

package/double-ratchet.js

@@ -1,352 +0,0 @@
-"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 = 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.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);
-                yield 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 env_2 = { stack: [], error: void 0, hasError: false };
-            try {
-                const lock = __addDisposableResource(env_2, yield this.mutex.acquire(), false);
-                const encrypted = types_1.EncryptedData.from(payload);
-                if (!(0, utils_1.verifyArrays)(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);
-                }
-                const key = this.previousKeys.get((0, utils_1.decodeBase64)(encrypted.publicKey) + encrypted.count.toString());
-                if (!key)
-                    throw new Error("Error calculating key");
-                yield this.save();
-                const cleartext = crypto_1.default.box.decrypt(encrypted.ciphertext, encrypted.nonce, key);
-                if (!cleartext)
-                    throw new Error("Error decrypting ciphertext");
-                return cleartext;
-            }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
-            }
-            finally {
-                __disposeResources(env_2);
-            }
-        });
-    }
-    /**
-     * 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.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);
-        if (out && !super.delete(key))
-            throw new Error();
-        return out;
-    }
-}

package/node.d.ts

@@ -1,38 +0,0 @@
-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

@@ -1,139 +0,0 @@
-"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/test.js

@@ -1,28 +0,0 @@
-"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 });
-const utils_1 = require("@freesignal/utils");
-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)));
-    }));
-}));