@freesignal/protocol 0.6.2 → 0.7.1

package/dist/double-ratchet.d.ts

@@ -20,9 +20,11 @@ import { IdentityKey, UserId } from "./types";
 export interface ExportedKeySession {
     identityKey: string;
     secretKey: string;
-    rootKey?: string;
+    rootKey: string;
     sendingChain?: ExportedKeyChain;
     receivingChain?: ExportedKeyChain;
+    headerKey?: string;
+    headerKeys: [string, Uint8Array][];
     previousKeys: [string, Uint8Array][];
 }
 export interface EncryptionKeys {
@@ -44,19 +46,24 @@ export declare class KeySession {
     static readonly maxCount = 65536;
     readonly identityKey: IdentityKey;
     private keyPair;
-    private rootKey?;
+    private rootKey;
     private sendingChain?;
     private receivingChain?;
+    private readonly headerKeys;
+    private headerKey?;
     private nextHeaderKey?;
     private previousKeys;
-    constructor({ identityKey, secretKey, remoteKey, rootKey }: {
+    constructor({ identityKey, secretKey, remoteKey, rootKey, headerKey, nextHeaderKey }: {
         identityKey: IdentityKey;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
-        rootKey?: Uint8Array;
+        rootKey: Uint8Array;
+        headerKey?: Uint8Array;
+        nextHeaderKey?: Uint8Array;
     });
     get userId(): UserId;
     private getChain;
+    getHeaderKey(hash?: string): Uint8Array | undefined;
     getSendingKey(): PrivateEncryptionKeys | undefined;
     getReceivingKey(encryptionKeys: EncryptionKeys): Uint8Array | undefined;
     /**
@@ -83,6 +90,8 @@ interface ExportedKeyChain {
     publicKey: string;
     remoteKey: string;
     chainKey: string;
+    headerKey?: string;
+    nextHeaderKey: string;
     count: number;
     previousCount: number;
 }

package/dist/double-ratchet.js

@@ -30,41 +30,40 @@ const types_1 = require("./types");
  * Used for forward-secure encryption and decryption of messages.
  */
 class KeySession {
-    //headerKey?: Uint8Array, nextHeaderKey?: Uint8Array,
-    constructor({ identityKey, secretKey, remoteKey, rootKey }) {
+    constructor({ identityKey, secretKey, remoteKey, rootKey, headerKey, nextHeaderKey }) {
+        this.headerKeys = new Map();
         this.previousKeys = new KeyMap();
         this.identityKey = identityKey;
         this.keyPair = crypto_1.default.ECDH.keyPair(secretKey);
-        if (rootKey)
-            this.rootKey = rootKey;
-        //if (opts.nextHeaderKey)
-        //    this.nextHeaderKey = opts.nextHeaderKey;
+        this.rootKey = rootKey;
+        if (headerKey)
+            this.headerKey = headerKey;
+        if (nextHeaderKey) {
+            this.nextHeaderKey = nextHeaderKey;
+            this.headerKeys.set((0, utils_1.decodeBase64)(crypto_1.default.hash(nextHeaderKey)), nextHeaderKey);
+        }
         if (remoteKey) {
-            this.sendingChain = this.getChain(remoteKey); //, opts.headerKey);
+            this.sendingChain = this.getChain(remoteKey, this.headerKey);
+            this.headerKey = undefined;
         }
     }
     get userId() {
         return this.identityKey.userId;
     }
-    //headerKey?: Uint8Array,
-    getChain(remoteKey, previousCount) {
+    getChain(remoteKey, headerKey, 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 * 3);
         this.rootKey = hashkey.subarray(0, KeySession.keyLength);
-        //hashkey.subarray(KeySession.keyLength * 2), headerKey,
-        return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength, KeySession.keyLength * 2), previousCount);
+        return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength, KeySession.keyLength * 2), hashkey.subarray(KeySession.keyLength * 2), headerKey, previousCount);
+    }
+    getHeaderKey(hash) {
+        var _a, _b;
+        if (!hash)
+            return (_a = this.headerKey) !== null && _a !== void 0 ? _a : (_b = this.sendingChain) === null || _b === void 0 ? void 0 : _b.headerKey;
+        return this.headerKeys.get(hash);
     }
-    /*public getHeaderKeys(): {
-        readonly sending?: Uint8Array,
-        readonly receiving?: Uint8Array
-    } {
-        return {
-            sending: this.sendingChain?.headerKey,
-            receiving: (this.receivingChain?.headerKey ?? this.receivingChain?.nextHeaderKey) ?? this.nextHeaderKey
-        }
-    }*/
     getSendingKey() {
         if (!this.sendingChain)
             return;
@@ -78,19 +77,21 @@ class KeySession {
         };
     }
     getReceivingKey(encryptionKeys) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         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.nextHeaderKey ?? this.receivingChain?.nextHeaderKey
-                this.receivingChain = this.getChain(encryptionKeys.publicKey, (_c = this.receivingChain) === null || _c === void 0 ? void 0 : _c.count);
-                this.nextHeaderKey = undefined;
+                this.receivingChain = this.getChain(encryptionKeys.publicKey, (_c = this.nextHeaderKey) !== null && _c !== void 0 ? _c : (_d = this.receivingChain) === null || _d === void 0 ? void 0 : _d.nextHeaderKey, (_e = this.receivingChain) === null || _e === void 0 ? void 0 : _e.count);
+                this.headerKeys.set((0, utils_1.decodeBase64)(crypto_1.default.hash(this.receivingChain.nextHeaderKey)), this.receivingChain.nextHeaderKey);
+                if (this.nextHeaderKey)
+                    this.nextHeaderKey = undefined;
                 this.keyPair = crypto_1.default.ECDH.keyPair();
-                //this.sendingChain?.nextHeaderKey,
-                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_d = this.sendingChain) === null || _d === void 0 ? void 0 : _d.count);
+                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_f = this.headerKey) !== null && _f !== void 0 ? _f : (_g = this.sendingChain) === null || _g === void 0 ? void 0 : _g.nextHeaderKey, (_h = this.sendingChain) === null || _h === void 0 ? void 0 : _h.count);
+                if (this.headerKey)
+                    this.headerKey = undefined;
             }
             if (!this.receivingChain)
                 throw new Error("Error initializing receivingChain");
@@ -117,9 +118,11 @@ class KeySession {
         return {
             identityKey: this.identityKey.toString(),
             secretKey: (0, utils_1.decodeBase64)(this.keyPair.secretKey),
-            rootKey: this.rootKey ? (0, utils_1.decodeBase64)(this.rootKey) : undefined,
+            rootKey: (0, utils_1.decodeBase64)(this.rootKey),
             sendingChain: (_a = this.sendingChain) === null || _a === void 0 ? void 0 : _a.toJSON(),
             receivingChain: (_b = this.receivingChain) === null || _b === void 0 ? void 0 : _b.toJSON(),
+            headerKey: this.headerKey ? (0, utils_1.decodeBase64)(this.headerKey) : undefined,
+            headerKeys: Array.from(this.headerKeys.entries()),
             previousKeys: Array.from(this.previousKeys.entries())
         };
     }
@@ -130,7 +133,7 @@ class KeySession {
      * @returns session with the state parsed.
      */
     static from(data) {
-        const session = new KeySession({ identityKey: types_1.IdentityKey.from(data.identityKey), secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: data.rootKey ? (0, utils_1.encodeBase64)(data.rootKey) : undefined });
+        const session = new KeySession({ identityKey: types_1.IdentityKey.from(data.identityKey), secretKey: (0, utils_1.encodeBase64)(data.secretKey), rootKey: (0, utils_1.encodeBase64)(data.rootKey) });
         session.sendingChain = data.sendingChain ? KeyChain.from(data.sendingChain) : undefined;
         session.receivingChain = data.receivingChain ? KeyChain.from(data.receivingChain) : undefined;
         session.previousKeys = new KeyMap(data.previousKeys);
@@ -143,11 +146,12 @@ KeySession.version = 1;
 KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
 KeySession.maxCount = 65536;
 class KeyChain {
-    //public readonly nextHeaderKey: Uint8Array, public readonly headerKey?: Uint8Array,
-    constructor(publicKey, remoteKey, chainKey, previousCount = 0) {
+    constructor(publicKey, remoteKey, chainKey, nextHeaderKey, headerKey, previousCount = 0) {
         this.publicKey = publicKey;
         this.remoteKey = remoteKey;
         this.chainKey = chainKey;
+        this.nextHeaderKey = nextHeaderKey;
+        this.headerKey = headerKey;
         this.previousCount = previousCount;
         this._count = 0;
     }
@@ -168,16 +172,16 @@ class KeyChain {
         return {
             publicKey: (0, utils_1.decodeBase64)(this.publicKey),
             remoteKey: (0, utils_1.decodeBase64)(this.remoteKey),
+            headerKey: this.headerKey ? (0, utils_1.decodeBase64)(this.headerKey) : undefined,
+            nextHeaderKey: (0, utils_1.decodeBase64)(this.nextHeaderKey),
             chainKey: (0, utils_1.decodeBase64)(this.chainKey),
-            //nextHeaderKey: decodeBase64(this.nextHeaderKey),
-            //headerKey: this.headerKey ? decodeBase64(this.headerKey) : undefined,
             count: this.count,
             previousCount: this.previousCount
         };
     }
     static from(obj) {
-        //encodeBase64(obj.nextHeaderKey), obj.headerKey ? encodeBase64(obj.headerKey) : undefined,
-        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), obj.previousCount);
+        //
+        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), (0, utils_1.encodeBase64)(obj.nextHeaderKey), obj.headerKey ? (0, utils_1.encodeBase64)(obj.headerKey) : undefined, obj.previousCount);
         chain._count = obj.count;
         return chain;
     }

package/dist/index.d.ts

@@ -18,23 +18,8 @@
  */
 import { LocalStorage, Crypto, Database, KeyExchangeDataBundle } from "@freesignal/interfaces";
 import { ExportedKeySession } from "./double-ratchet";
-import { IdentityKey, PrivateIdentityKey } from "./types";
+import { PrivateIdentityKey } from "./types";
 import { BootstrapRequest, FreeSignalNode } from "./node";
-/**
- * Creates a new Double Ratchet session for secure message exchange.
- *
- * @param opts - Optional parameters for session initialization.
- * @param opts.secretKey - The local party's secret key as a Uint8Array.
- * @param opts.remoteKey - The remote party's public key as a Uint8Array.
- * @param opts.rootKey - An optional root key to initialize the session.
- * @returns A new instance of {@link 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}.
- */
 /**
  * Generates identity key
  *
@@ -46,7 +31,6 @@ 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>;
     bootstraps: LocalStorage<string, BootstrapRequest>;
 }>, privateIdentityKey?: PrivateIdentityKey): FreeSignalNode;

package/dist/index.js

@@ -40,27 +40,6 @@ exports.createNode = createNode;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const types_1 = require("./types");
 const node_1 = require("./node");
-/**
- * Creates a new Double Ratchet session for secure message exchange.
- *
- * @param opts - Optional parameters for session initialization.
- * @param opts.secretKey - The local party's secret key as a Uint8Array.
- * @param opts.remoteKey - The remote party's public key as a Uint8Array.
- * @param opts.rootKey - An optional root key to initialize the session.
- * @returns A new instance of {@link KeySession}.
- */
-/*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}.
- */
-/*export function createKeyExchange(storage: { keys: LocalStorage<string, Crypto.KeyPair>, sessions: LocalStorage<string, ExportedKeySession> }, privateIdentityKey?: PrivateIdentityKey): KeyExchange {
-    return new KeyExchange(storage, privateIdentityKey);
-}*/
 /**
  * Generates identity key
  *

package/dist/node.d.ts

@@ -20,16 +20,28 @@ import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData
 import { Datagram, DatagramHeader, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
 import { KeyExchange } from "./x3dh";
 import { ExportedKeySession, KeySession } from "./double-ratchet";
-export declare class BootstrapRequest {
+import EventEmitter, { EventCall } from "easyemitter.ts";
+export declare class BootstrapRequest extends EventEmitter<'change', BootstrapRequest> {
     #private;
     readonly senderId: UserId | string;
-    private readonly datagram;
-    constructor(senderId: UserId | string, datagram: Datagram);
+    private readonly keyExchangeData;
+    constructor(senderId: UserId | string, keyExchangeData: KeyExchangeData);
+    onChange: EventCall<'change', BootstrapRequest>;
     get status(): "pending" | "accepted" | "denied";
-    get(): Promise<Datagram | undefined>;
-    accept(): Promise<Datagram | undefined>;
+    get data(): KeyExchangeData | undefined;
+    accept(): void;
     deny(): void;
 }
+type NodeEventData = {
+    header: DatagramHeader;
+    payload?: Uint8Array;
+    datagram?: Datagram;
+    request?: BootstrapRequest;
+};
+type MessageEventData = {
+    header: DatagramHeader;
+    payload: Uint8Array;
+};
 export declare class FreeSignalNode {
     protected readonly privateIdentityKey: PrivateIdentityKey;
     protected readonly sessions: SessionMap;
@@ -37,36 +49,35 @@ export declare class FreeSignalNode {
     protected readonly keyExchange: KeyExchange;
     protected readonly discovers: Set<string>;
     protected readonly bootstraps: LocalStorage<string, BootstrapRequest>;
+    protected readonly emitter: EventEmitter<"message" | "send" | "handshake" | "ping" | "bootstrap", NodeEventData>;
     constructor(storage: Database<{
         sessions: LocalStorage<string, ExportedKeySession>;
         keyExchange: LocalStorage<string, Crypto.KeyPair>;
         bundles: LocalStorage<string, KeyExchangeDataBundle>;
         bootstraps: LocalStorage<string, BootstrapRequest>;
     }>, privateIdentityKey?: PrivateIdentityKey);
+    protected messageHandler: EventCall<"message", NodeEventData>;
+    protected sendHandler: EventCall<"send", NodeEventData>;
+    protected handshakeHandler: EventCall<"handshake", NodeEventData>;
+    protected bootstrapHandler: EventCall<"bootstrap", NodeEventData>;
+    onMessage: (data: MessageEventData) => void;
+    onSend: (data: Uint8Array) => void;
+    onHandshake: (userId: UserId) => void;
+    onRequest: (request: BootstrapRequest) => void;
+    getRequest(userId: string): Promise<BootstrapRequest | undefined>;
+    waitHandshaked(userId: UserId | string, timeout?: number): Promise<void>;
     get identityKey(): IdentityKey;
     get userId(): UserId;
-    onRequest: (request: BootstrapRequest) => void;
-    getRequest(userId: string): Promise<Datagram | undefined>;
     protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
-    packHandshake(data: KeyExchangeData): Promise<Datagram>;
-    packHandshake(receiverId: string | UserId): 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>;
-    packGetBootstrap(receiverId: string | UserId): Promise<Datagram>;
+    sendHandshake(data: KeyExchangeData): Promise<void>;
+    sendHandshake(receiverId: string | UserId): Promise<void>;
+    sendData<T>(receiverId: string | UserId, data: T): Promise<void>;
+    sendRelay(receiverId: string | UserId, data: Datagram): Promise<void>;
+    sendPing(receiverId: string | UserId): Promise<void>;
+    sendDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<void>;
+    sendBootstrap(receiverId: string | UserId): Promise<void>;
     protected decrypt(datagram: Datagram): Promise<Uint8Array>;
-    /**
-     * Open the datagram and execute operation of Discover and Handshake.
-     *
-     * @param datagram
-     * @returns Header and decrypted payload
-     */
-    open(datagram: Datagram | Uint8Array): Promise<{
-        header: DatagramHeader;
-        payload?: Uint8Array;
-        datagram?: Datagram;
-    }>;
+    protected open(datagram: Datagram | Uint8Array): Promise<void>;
 }
 declare class SessionMap implements LocalStorage<string, KeySession> {
     readonly storage: LocalStorage<string, ExportedKeySession>;

package/dist/node.js

@@ -49,31 +49,31 @@ const double_ratchet_1 = require("./double-ratchet");
 const _1 = require(".");
 const utils_1 = require("@freesignal/utils");
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
-class BootstrapRequest {
-    constructor(senderId, datagram) {
+const easyemitter_ts_1 = __importDefault(require("easyemitter.ts"));
+class BootstrapRequest extends easyemitter_ts_1.default {
+    constructor(senderId, keyExchangeData) {
+        super();
         this.senderId = senderId;
-        this.datagram = datagram;
+        this.keyExchangeData = keyExchangeData;
         _BootstrapRequest_status.set(this, 'pending');
+        this.onChange = () => { };
+        this.on('change', (data) => this.onChange(data));
     }
     get status() {
         return __classPrivateFieldGet(this, _BootstrapRequest_status, "f");
     }
-    get() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return __classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted' ? this.datagram : undefined;
-        });
+    get data() {
+        return __classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted' ? this.keyExchangeData : undefined;
     }
     accept() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.status === 'pending')
-                __classPrivateFieldSet(this, _BootstrapRequest_status, 'accepted', "f");
-            return yield this.get();
-        });
+        if (this.status === 'pending')
+            __classPrivateFieldSet(this, _BootstrapRequest_status, 'accepted', "f");
+        this.emit('change', this);
     }
     deny() {
         if (this.status === 'pending')
             __classPrivateFieldSet(this, _BootstrapRequest_status, 'denied', "f");
-        return;
+        this.emit('change', this);
     }
 }
 exports.BootstrapRequest = BootstrapRequest;
@@ -81,25 +81,43 @@ _BootstrapRequest_status = new WeakMap();
 class FreeSignalNode {
     constructor(storage, privateIdentityKey) {
         this.discovers = new Set();
+        this.emitter = new easyemitter_ts_1.default();
+        this.messageHandler = (data) => { var _a, _b; return this.onMessage({ header: (_a = data.data) === null || _a === void 0 ? void 0 : _a.header, payload: (_b = data.data) === null || _b === void 0 ? void 0 : _b.payload }); };
+        this.sendHandler = (data) => this.onSend(data.data.datagram.toBytes());
+        this.handshakeHandler = (data) => this.onHandshake(types_1.UserId.from(data.data.header.sender));
+        this.bootstrapHandler = (data) => { var _a; return this.onRequest((_a = data.data) === null || _a === void 0 ? void 0 : _a.request); };
+        this.onMessage = () => { };
+        this.onSend = () => { };
+        this.onHandshake = () => { };
         this.onRequest = () => { };
         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.bundles = storage.bundles;
         this.bootstraps = storage.bootstraps;
-    }
-    get identityKey() {
-        return this.privateIdentityKey.identityKey;
-    }
-    get userId() {
-        return types_1.UserId.fromKey(this.identityKey);
+        this.emitter.on('message', this.messageHandler);
+        this.emitter.on('send', this.sendHandler);
+        this.emitter.on('handshake', this.handshakeHandler);
+        this.emitter.on('bootstrap', this.bootstrapHandler);
     }
     getRequest(userId) {
+        return this.bootstraps.get(userId);
+    }
+    waitHandshaked(userId, timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            return (_a = (yield this.bootstraps.get(userId))) === null || _a === void 0 ? void 0 : _a.get();
+            if (timeout)
+                setTimeout(() => { throw new Error(); }, timeout);
+            while (((_a = (yield this.emitter.wait('handshake', timeout))) === null || _a === void 0 ? void 0 : _a.header.sender) !== userId.toString())
+                ;
         });
     }
+    get identityKey() {
+        return this.privateIdentityKey.identityKey;
+    }
+    get userId() {
+        return this.identityKey.userId;
+    }
     encrypt(receiverId, protocol, data) {
         return __awaiter(this, void 0, void 0, function* () {
             if (receiverId instanceof types_1.UserId)
@@ -112,35 +130,50 @@ class FreeSignalNode {
             return new types_1.Datagram(this.userId.toString(), receiverId, protocol, encrypted).sign(this.privateIdentityKey.signatureKey);
         });
     }
-    packHandshake(data) {
+    sendHandshake(data) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             if (typeof data === 'string' || data instanceof types_1.UserId) {
-                //console.debug("Packing Handshake Ack");
+                //console.debug("Sending Handshake Ack");
                 const userId = data.toString();
                 const identityKey = (_a = (yield this.sessions.get(userId))) === null || _a === void 0 ? void 0 : _a.identityKey;
                 if (!identityKey)
                     throw new Error("Missing user");
-                const res = yield this.encrypt(userId, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey));
-                return res;
+                const datagram = yield this.encrypt(userId, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey));
+                this.emitter.emit('send', { header: datagram.header, datagram });
+                return;
             }
-            //console.debug("Packing Handshake Syn");
+            //console.debug("Sending Handshake Syn");
             const { session, message } = yield this.keyExchange.digestData(data, (0, utils_1.encodeData)(yield this.keyExchange.generateBundle()));
             yield this.sessions.set(session.userId.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);
+            const datagram = 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);
+            this.emitter.emit('send', { header: datagram.header, datagram });
+        });
+    }
+    sendData(receiverId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Sending Data");
+            const datagram = yield this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
+            this.emitter.emit('send', { header: datagram.header, datagram });
         });
     }
-    packData(receiverId, data) {
-        //console.debug("Packing Data");
-        return this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data));
+    sendRelay(receiverId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Sending Relay");
+            const datagram = yield this.encrypt(receiverId, types_1.Protocols.RELAY, data.toBytes());
+            this.emitter.emit('send', { header: datagram.header, datagram });
+        });
     }
-    packRelay(receiverId, data) {
-        //console.debug("Packing Relay");
-        return this.encrypt(receiverId, types_1.Protocols.RELAY, data.toBytes());
+    sendPing(receiverId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Sending Ping");
+            const datagram = new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.PING);
+            this.emitter.emit('send', { header: datagram.header, datagram });
+        });
     }
-    packDiscover(receiverId, discoverId) {
+    sendDiscover(receiverId, discoverId) {
         return __awaiter(this, void 0, void 0, function* () {
-            //console.debug("Packing Discover");
+            //console.debug("Sending Discover");
             if (receiverId instanceof types_1.UserId)
                 receiverId = receiverId.toString();
             if (discoverId instanceof types_1.UserId)
@@ -150,19 +183,17 @@ class FreeSignalNode {
                 discoverId
             };
             this.discovers.add(receiverId);
-            return this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(message));
+            const datagram = yield this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(message));
+            this.emitter.emit('send', { header: datagram.header, datagram });
         });
     }
-    packBootstrap(receiverId) {
+    sendBootstrap(receiverId) {
         return __awaiter(this, void 0, void 0, function* () {
-            //console.debug("Packing Bootstrap");
-            return new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
-        });
-    }
-    packGetBootstrap(receiverId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            //console.debug("Packing GetBootstrap");
-            return new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP);
+            //console.debug("Sending Bootstrap");
+            if (yield this.sessions.has(receiverId.toString()))
+                throw new Error("Session exists");
+            const datagram = new types_1.Datagram(this.userId.toString(), receiverId.toString(), types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
+            this.emitter.emit('send', { header: datagram.header, datagram });
         });
     }
     decrypt(datagram) {
@@ -183,20 +214,11 @@ class FreeSignalNode {
             return decrypted;
         });
     }
-    /**
-     * Open the datagram and execute operation of Discover and Handshake.
-     *
-     * @param datagram
-     * @returns Header and decrypted payload
-     */
     open(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             if (datagram instanceof Uint8Array)
                 datagram = types_1.Datagram.from(datagram);
-            let out = {
-                header: types_1.DatagramHeader.from(datagram.header)
-            };
             switch (datagram.protocol) {
                 case types_1.Protocols.HANDSHAKE:
                     if (!datagram.payload)
@@ -209,7 +231,8 @@ class FreeSignalNode {
                             throw new Error("Missing user");
                         if (!(0, utils_1.compareBytes)(payload, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, identityKey.exchangeKey)))
                             throw new Error("Error validating handshake data");
-                        return out;
+                        this.emitter.emit('handshake', { header: datagram.header });
+                        return;
                     }
                     //console.debug("Opening Handshake Syn");
                     const data = (0, utils_1.decodeData)(datagram.payload);
@@ -218,18 +241,17 @@ class FreeSignalNode {
                     const { session, associatedData } = yield this.keyExchange.digestMessage(data);
                     yield this.sessions.set(session.userId.toString(), session);
                     yield this.bundles.set(session.userId.toString(), (0, utils_1.decodeData)(associatedData));
-                    out.datagram = yield this.packHandshake(session.userId);
-                    if (!out.datagram)
-                        throw new Error("Error during handshake");
-                    return out;
+                    yield this.sendHandshake(session.userId);
+                    this.emitter.emit('handshake', { header: datagram.header });
+                    return;
                 case types_1.Protocols.MESSAGE:
                     //console.debug("Opening Message");
-                    out.payload = yield this.decrypt(datagram);
-                    return out;
+                    this.emitter.emit('message', { header: datagram.header, payload: yield this.decrypt(datagram) });
+                    return;
                 case types_1.Protocols.RELAY:
                     //console.debug("Opening Relay");
-                    out.payload = yield this.decrypt(datagram);
-                    return out;
+                    this.emitter.emit('send', { header: types_1.Datagram.from(yield this.decrypt(datagram)) });
+                    return;
                 case types_1.Protocols.DISCOVER:
                     //console.debug("Opening Discover");
                     const message = (0, utils_1.decodeData)(yield this.decrypt(datagram));
@@ -241,12 +263,12 @@ class FreeSignalNode {
                         else {
                             const bundle = yield this.bundles.get(message.discoverId);
                             if (!bundle)
-                                return out;
+                                return;
                             const { version, identityKey, signedPreKey, signature } = bundle;
                             const onetimePreKey = bundle.onetimePreKeys.shift();
                             if (!onetimePreKey) {
                                 yield this.bundles.delete(message.discoverId);
-                                return out;
+                                return;
                             }
                             data = {
                                 version,
@@ -257,31 +279,33 @@ class FreeSignalNode {
                             };
                         }
                         const response = { type: types_1.DiscoverType.RESPONSE, discoverId: message.discoverId, data };
-                        out.datagram = yield this.encrypt(datagram.sender, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response));
+                        this.emitter.emit('send', 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);
                         if (message.data)
-                            out.datagram = yield this.packHandshake(message.data);
+                            yield this.sendHandshake(message.data);
                     }
-                    return out;
+                    return;
                 case types_1.Protocols.BOOTSTRAP:
                     //console.debug("Opening 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)))
-                            new Error("Malicious bootstrap request");
-                        const request = new BootstrapRequest(datagram.sender, yield this.packHandshake(data));
-                        yield this.bootstraps.set(datagram.sender, request);
-                        this.onRequest(request);
-                    }
-                    ;
-                    const handshakeDatagram = yield ((_b = (yield this.bootstraps.get(datagram.sender))) === null || _b === void 0 ? void 0 : _b.get());
-                    if (handshakeDatagram)
-                        out.datagram = handshakeDatagram;
-                    return out;
+                    if (!datagram.payload)
+                        throw new Error("Invalid Bootstrap");
+                    const keyExchangeData = (0, utils_1.decodeData)(datagram.payload);
+                    if (!(0, utils_1.compareBytes)(types_1.UserId.fromKey(keyExchangeData.identityKey).toBytes(), (0, utils_1.encodeBase64)(datagram.sender)))
+                        new Error("Malicious bootstrap request");
+                    const request = new BootstrapRequest(datagram.sender, keyExchangeData);
+                    request.onChange = () => {
+                        if (!request.data)
+                            throw new Error("Error sending handshake");
+                        this.sendHandshake(request.data);
+                    };
+                    yield this.bootstraps.set(datagram.sender, request);
+                    this.emitter.emit('bootstrap', { header: datagram.header, request });
+                    return;
                 case types_1.Protocols.PING:
-                    return out;
+                    this.emitter.emit('ping', { header: datagram.header });
+                    return;
                 default:
                     throw new Error("Invalid protocol");
             }

package/dist/types.d.ts

@@ -128,7 +128,7 @@ export declare class Datagram implements Encodable, DatagramHeader {
     get payload(): Uint8Array | undefined;
     get signature(): string | undefined;
     private get unsigned();
-    get header(): Uint8Array;
+    get header(): DatagramHeader;
     toBytes(): Uint8Array;
     sign(secretKey: Uint8Array): SignedDatagram;
     toString(): string;
@@ -154,20 +154,31 @@ export declare class EncryptionHeader implements EncryptionKeys, Encodable {
     static from(data: Uint8Array | EncryptionHeader): EncryptionHeader;
 }
 export declare class EncryptedData implements Encodable {
-    readonly header: Uint8Array;
-    readonly nonce: Uint8Array;
-    readonly payload: Uint8Array;
     static readonly version = 1;
     static readonly nonceLength: number;
     private _version;
-    constructor(header: Uint8Array, nonce: Uint8Array, payload: Uint8Array);
+    readonly header: Uint8Array;
+    readonly hashkey?: Uint8Array;
+    readonly nonce?: Uint8Array;
+    readonly payload: Uint8Array;
+    constructor(opts: {
+        header: Uint8Array;
+        payload: Uint8Array;
+    });
+    constructor(opts: {
+        header: Uint8Array;
+        hashkey: Uint8Array;
+        nonce: Uint8Array;
+        payload: Uint8Array;
+    });
     get version(): number;
     get length(): number;
     toBytes(): Uint8Array;
     toJSON(): {
         version: number;
         header: string;
-        nonce: string;
+        hashkey?: string;
+        nonce?: string;
         payload: string;
     };
     static from(data: Uint8Array | EncryptedData): EncryptedData;

package/dist/types.js

@@ -35,66 +35,34 @@ exports.encryptData = encryptData;
 exports.decryptData = decryptData;
 const utils_1 = require("@freesignal/utils");
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
-/*export function encryptData(session: KeySession, data: Uint8Array): EncryptedData {
+function encryptData(session, data) {
     const key = session.getSendingKey();
     if (!key)
         throw new Error("Error generating key");
-    const nonce = crypto.randomBytes(EncryptionHeader.nonceLength);
-    const ciphertext = crypto.box.encrypt(data, nonce, key.secretKey);
-    const headerKey = session.getHeaderKeys().sending;
-    //console.debug(session.userId.toString(), "Sending: ", decodeBase64(headerKey ?? new Uint8Array()))
+    const nonce = crypto_1.default.randomBytes(EncryptionHeader.nonceLength);
+    const payload = crypto_1.default.box.encrypt(data, nonce, key.secretKey);
     let header = new EncryptionHeader(key, nonce).toBytes();
-    const headerNonce = crypto.randomBytes(EncryptionHeader.nonceLength)
+    const headerKey = session.getHeaderKey();
+    if (!headerKey)
+        return new EncryptedData({ header, payload });
+    const headerNonce = crypto_1.default.randomBytes(EncryptionHeader.nonceLength);
     if (headerKey)
-        header = crypto.box.encrypt(header, headerNonce, headerKey);
-    const test = new EncryptedData(header, headerNonce, ciphertext);
-    return test;
+        header = crypto_1.default.box.encrypt(header, headerNonce, headerKey);
+    return new EncryptedData({ hashkey: crypto_1.default.hash(headerKey !== null && headerKey !== void 0 ? headerKey : new Uint8Array(32).fill(0)), header, nonce: headerNonce, payload });
 }
-
-export function decryptData(session: KeySession, encryptedData: Uint8Array): Uint8Array {
+function decryptData(session, encryptedData) {
     const encrypted = EncryptedData.from(encryptedData);
-    const headerKey = session.getHeaderKeys().receiving;
-    const nextHeaderKey = session.getHeaderKeys().nextReciving;
-    let headerData: Uint8Array | undefined;
-    try {
+    let headerData = encrypted.header;
+    if (encrypted.hashkey && encrypted.nonce) {
+        const headerKey = session.getHeaderKey((0, utils_1.decodeBase64)(encrypted.hashkey));
         if (!headerKey)
-            throw new Error("Error generating key");
-        headerData = crypto.box.decrypt(encrypted.header, encrypted.nonce, headerKey);
-        if (!headerData)
+            throw new Error("Error getting key");
+        const data = crypto_1.default.box.decrypt(encrypted.header, encrypted.nonce, headerKey);
+        if (!data)
             throw new Error("Error calculating header");
-        //console.debug(session.userId.toString(), "Receiving: ", decodeBase64(session.getHeaderKeys().receiving ?? new Uint8Array()))
-    } catch {
-        if (!nextHeaderKey)
-            throw new Error("Error generating key");
-        headerData = crypto.box.decrypt(encrypted.header, encrypted.nonce, nextHeaderKey);
-        if (!headerData) {
-            //console.debug(session.toJSON());
-            throw new Error("Error calculating header");
-        }
-        //console.debug(session.userId.toString(), "NextReceiving: ", decodeBase64(session.getHeaderKeys().nextReciving ?? new Uint8Array()))
+        headerData = data;
     }
-    const header = EncryptionHeader.from(headerData!);
-    const key = session.getReceivingKey(header);
-    if (!key)
-        throw new Error("Error calculating key");
-    const decrypted = crypto.box.decrypt(encrypted.payload, header.nonce, key);
-    if (!decrypted)
-        throw new Error("Error decrypting data");
-    return decrypted;
-}*/
-function encryptData(session, data) {
-    const key = session.getSendingKey();
-    if (!key)
-        throw new Error("Error generating key");
-    const nonce = crypto_1.default.randomBytes(EncryptionHeader.nonceLength);
-    const ciphertext = crypto_1.default.box.encrypt(data, nonce, key.secretKey);
-    let header = new EncryptionHeader(key, nonce).toBytes();
-    const test = new EncryptedData(header, crypto_1.default.randomBytes(EncryptionHeader.nonceLength), ciphertext);
-    return test;
-}
-function decryptData(session, encryptedData) {
-    const encrypted = EncryptedData.from(encryptedData);
-    const header = EncryptionHeader.from(encrypted.header);
+    const header = EncryptionHeader.from(headerData);
     const key = session.getReceivingKey(header);
     if (!key)
         throw new Error("Error calculating key");
@@ -318,7 +286,7 @@ class Datagram {
         return data.subarray(0, data.length - (this._signature ? crypto_1.default.EdDSA.signatureLength : 0));
     }
     get header() {
-        return this.toBytes().slice(0, DatagramHeader.headerLength);
+        return DatagramHeader.from(this.toBytes().slice(0, DatagramHeader.headerLength));
     }
     toBytes() {
         var _a, _b, _c;
@@ -400,11 +368,12 @@ class EncryptionHeader {
     static from(data) {
         if (data instanceof EncryptionHeader)
             data = data.toBytes();
+        let offset = 0;
         return new EncryptionHeader({
-            count: (0, utils_1.bytesToNumber)(data.subarray(0, EncryptionHeader.countLength)),
-            previous: (0, utils_1.bytesToNumber)(data.subarray(EncryptionHeader.countLength, EncryptionHeader.countLength * 2)),
-            publicKey: data.subarray(EncryptionHeader.countLength * 2, EncryptionHeader.countLength * 2 + EncryptionHeader.keyLength)
-        }, data.subarray(EncryptionHeader.countLength * 2 + EncryptionHeader.keyLength, EncryptionHeader.countLength * 2 + EncryptionHeader.keyLength + EncryptedData.nonceLength));
+            count: (0, utils_1.bytesToNumber)(data.subarray(offset, offset += EncryptionHeader.countLength)),
+            previous: (0, utils_1.bytesToNumber)(data.subarray(offset, offset += EncryptionHeader.countLength)),
+            publicKey: data.subarray(offset, offset += EncryptionHeader.keyLength)
+        }, data.subarray(offset, offset += EncryptedData.nonceLength));
     }
 }
 exports.EncryptionHeader = EncryptionHeader;
@@ -412,11 +381,12 @@ EncryptionHeader.keyLength = crypto_1.default.box.keyLength;
 EncryptionHeader.nonceLength = crypto_1.default.box.nonceLength;
 EncryptionHeader.countLength = 2;
 class EncryptedData {
-    constructor(header, nonce, payload) {
+    constructor({ hashkey, header, nonce, payload }) {
+        this._version = EncryptedData.version;
         this.header = header;
+        this.hashkey = hashkey;
         this.nonce = nonce;
         this.payload = payload;
-        this._version = EncryptedData.version;
     }
     get version() {
         return this._version;
@@ -425,22 +395,36 @@ class EncryptedData {
         return this.toBytes().length;
     }
     toBytes() {
-        return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this._version, 1), (0, utils_1.numberToBytes)(this.header.length, 3), this.header, this.nonce, this.payload);
+        var _a, _b;
+        return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this._version | (this.hashkey && this.nonce ? 128 : 0), 1), (0, utils_1.numberToBytes)(this.header.length, 3), this.header, (_a = this.hashkey) !== null && _a !== void 0 ? _a : new Uint8Array(), (_b = this.nonce) !== null && _b !== void 0 ? _b : new Uint8Array, this.payload);
     }
     toJSON() {
         return {
             version: this._version,
             header: (0, utils_1.decodeBase64)(this.header),
-            nonce: (0, utils_1.decodeBase64)(this.nonce),
+            hashkey: this.hashkey ? (0, utils_1.decodeBase64)(this.hashkey) : undefined,
+            nonce: this.nonce ? (0, utils_1.decodeBase64)(this.nonce) : undefined,
             payload: (0, utils_1.decodeBase64)(this.payload)
         };
     }
     static from(data) {
         if (data instanceof EncryptedData)
             data = data.toBytes();
+        const versionByte = (0, utils_1.bytesToNumber)(data.subarray(0, 1));
         const headerLength = (0, utils_1.bytesToNumber)(data.subarray(1, 4));
-        const obj = new EncryptedData(data.subarray(4, 4 + headerLength), data.subarray(4 + headerLength, 4 + headerLength + this.nonceLength), data.subarray(4 + headerLength + this.nonceLength));
-        obj._version = (0, utils_1.bytesToNumber)(data.subarray(0, 1));
+        let offset = 4;
+        const header = data.subarray(offset, offset += headerLength);
+        let hashkey, nonce;
+        if ((versionByte & 128) > 0) {
+            hashkey = data.subarray(offset, offset += 32);
+            nonce = data.subarray(offset, offset += this.nonceLength);
+        }
+        const payload = data.subarray(offset);
+        if (!hashkey || !nonce)
+            var obj = new EncryptedData({ header, payload });
+        else
+            var obj = new EncryptedData({ header, hashkey, nonce, payload });
+        obj._version = versionByte & 127;
         return obj;
     }
 }

package/dist/x3dh.js

@@ -99,8 +99,7 @@ class KeyExchange {
                 ...crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, signedPreKey),
                 ...onetimePreKey ? crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, onetimePreKey) : new Uint8Array()
             ]), new Uint8Array(double_ratchet_1.KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.keyLength * 3);
-            //, headerKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), nextHeaderKey: derivedKey.subarray(KeySession.keyLength * 2)
-            const session = new double_ratchet_1.KeySession({ identityKey, remoteKey: identityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength) });
+            const session = new double_ratchet_1.KeySession({ identityKey, remoteKey: identityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength), headerKey: derivedKey.subarray(double_ratchet_1.KeySession.keyLength, double_ratchet_1.KeySession.keyLength * 2), nextHeaderKey: derivedKey.subarray(double_ratchet_1.KeySession.keyLength * 2) });
             const encrypted = (0, types_1.encryptData)(session, (0, utils_1.concatBytes)(crypto_1.default.hash(this.identityKey.toBytes()), crypto_1.default.hash(identityKey.toBytes()), associatedData !== null && associatedData !== void 0 ? associatedData : new Uint8Array()));
             if (!encrypted)
                 throw new Error("Decryption error");
@@ -135,8 +134,7 @@ class KeyExchange {
                 ...crypto_1.default.ECDH.scalarMult(signedPreKey.secretKey, ephemeralKey),
                 ...onetimePreKey ? crypto_1.default.ECDH.scalarMult(onetimePreKey.secretKey, ephemeralKey) : new Uint8Array()
             ]), new Uint8Array(double_ratchet_1.KeySession.keyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.keyLength * 3);
-            //nextHeaderKey: derivedKey.subarray(KeySession.keyLength, KeySession.keyLength * 2), headerKey: derivedKey.subarray(KeySession.keyLength * 2)
-            const session = new double_ratchet_1.KeySession({ identityKey, secretKey: this.privateIdentityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength) });
+            const session = new double_ratchet_1.KeySession({ identityKey, secretKey: this.privateIdentityKey.exchangeKey, rootKey: derivedKey.subarray(0, double_ratchet_1.KeySession.keyLength), nextHeaderKey: derivedKey.subarray(double_ratchet_1.KeySession.keyLength, double_ratchet_1.KeySession.keyLength * 2), headerKey: derivedKey.subarray(double_ratchet_1.KeySession.keyLength * 2) });
             const data = (0, types_1.decryptData)(session, (0, utils_1.encodeBase64)(message.associatedData));
             if (!data)
                 throw new Error("Error decrypting ACK message");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Signal Protocol implementation in javascript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",
@@ -37,9 +37,10 @@
     "@freesignal/crypto": "^0.3.0",
     "@freesignal/interfaces": "^0.2.0",
     "@freesignal/utils": "^1.4.1",
+    "easyemitter.ts": "^1.0.3",
     "semaphore.ts": "^0.2.0"
   },
   "devDependencies": {
     "@types/node": "^24.2.1"
   }
-}
+}

package/dist/test.d.ts

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

package/dist/test.js

@@ -1,48 +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(".");
-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(), bootstraps: new _1.AsyncMap() });
-const alice = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap(), bootstraps: new _1.AsyncMap() });
-setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
-    const bobBootstrap = yield bob.packBootstrap(alice.userId);
-    alice.onRequest = (request) => { request.accept(); };
-    const test = (yield alice.open(bobBootstrap)).datagram;
-    const aliceHandshake = yield alice.getRequest(bob.userId.toString());
-    if (!aliceHandshake)
-        throw new Error("Bootstrap Failed");
-    const bobHandshake = (yield bob.open(aliceHandshake)).datagram;
-    if (!bobHandshake)
-        throw new Error("Handshake Failed");
-    console.log(!!(yield alice.open(bobHandshake)).header);
-    const first = (yield bob.packData(alice.userId, "Hi Alice!")).toBytes();
-    console.log("Bob: ", (0, utils_1.decodeData)((yield alice.open(first)).payload));
-    const second = yield alice.packData(bob.userId, "Hi Bob!");
-    console.log("Test");
-    console.log("Alice: ", (0, utils_1.decodeData)((yield bob.open(second)).payload));
-    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: ", (0, utils_1.decodeData)((yield alice.open(data)).payload));
-    }));
-    const fourth = yield alice.packData(bob.userId, "Not so bad my man");
-    console.log("Alice: ", (0, utils_1.decodeData)((yield bob.open(fourth)).payload));
-    const fifth = yield Promise.all(["I'm thinking...", "His this secure?"].map(msg => bob.packData(alice.userId, msg)));
-    fifth.forEach((data) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log("Bob: ", (0, utils_1.decodeData)((yield alice.open(data)).payload));
-    }));
-    const msg = yield alice.packData(bob.userId, (0, utils_1.encodeData)("test"));
-    const relay = yield alice.packRelay(bob.userId, msg);
-    console.log((0, utils_1.compareBytes)(msg.toBytes(), (yield bob.open(relay)).payload));
-    //const testone = await Promise.all(Array(400).fill(0).map(() => alice.packData(bob.userId, decodeBase64(crypto.randomBytes(64)))));
-    //console.log(((await bob.open(testone[350])).payload));
-}));