@freesignal/protocol 0.9.0 → 0.9.1

package/dist/index.d.ts

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { PrivateIdentityKey } from "./types.js";
-import { FreeSignalNode } from "./node.js";
+import { FreeSignalNode, FreeSignalNodeState } from "./node.js";
 /**
  * Generates identity key
  *
@@ -26,5 +26,5 @@ import { FreeSignalNode } from "./node.js";
  */
 export declare function createIdentity(seed?: Uint8Array): PrivateIdentityKey;
 /** */
-export declare function createNode(privateIdentityKey?: PrivateIdentityKey): FreeSignalNode;
+export declare function createNode(args?: Partial<FreeSignalNodeState>): FreeSignalNode;
 export * from "./types.js";

package/dist/index.js

@@ -35,7 +35,7 @@ export function createIdentity(seed) {
     return PrivateIdentityKey.from(signatureKeyPair.secretKey, exchangeKeyPair.secretKey);
 }
 /** */
-export function createNode(privateIdentityKey) {
-    return new FreeSignalNode(privateIdentityKey);
+export function createNode(args) {
+    return new FreeSignalNode(args);
 }
 export * from "./types.js";

package/dist/node.d.ts

@@ -16,9 +16,9 @@
  * 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 { KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
+import { KeyExchangeDataBundle, KeyExchangeData, Crypto } from "@freesignal/interfaces";
 import { Datagram, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types.js";
-import { KeyExchange, KeyExchangeState } from "./x3dh.js";
+import { KeyExchange } from "./x3dh.js";
 import { ExportedKeySession as KeySessionState, KeySession } from "./double-ratchet.js";
 import { EventEmitter, EventCallback } from "easyemitter.ts";
 export declare class BootstrapRequest extends EventEmitter<'change', BootstrapRequest> {
@@ -55,7 +55,7 @@ export type FreeSignalNodeState = {
     sessions: Array<[string, KeySessionState]>;
     users: Array<[string, string]>;
     bundles: Array<[string, KeyExchangeDataBundle]>;
-    keyExchange: KeyExchangeState;
+    keyExchange: Array<[string, Crypto.KeyPair]>;
 };
 export declare class FreeSignalNode {
     protected readonly privateIdentityKey: PrivateIdentityKey;
@@ -65,7 +65,7 @@ export declare class FreeSignalNode {
     protected readonly keyExchange: KeyExchange;
     protected readonly bootstraps: Map<string, BootstrapRequest>;
     protected readonly emitter: EventEmitter<"error" | "debug" | "send" | "handshake" | "message" | "bootstrap", NodeEventData>;
-    constructor(privateIdentityKey?: PrivateIdentityKey);
+    constructor({ privateIdentityKey, sessions, users, bundles, keyExchange }?: Partial<FreeSignalNodeState>);
     protected messageHandler: EventCallback<NodeEventData, typeof this.emitter>;
     protected sendHandler: EventCallback<NodeEventData, typeof this.emitter>;
     protected handshakeHandler: EventCallback<NodeEventData, typeof this.emitter>;
@@ -82,16 +82,16 @@ export declare class FreeSignalNode {
     waitHandshaked(userId: UserId | string, timeout?: number): Promise<void>;
     get identityKey(): IdentityKey;
     get userId(): UserId;
-    protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): SendEventData;
-    sendHandshake(data: KeyExchangeData): void;
-    sendHandshake(session: KeySession): void;
-    sendHandshake(userId: UserId | string): void;
-    sendData<T>(receiverId: string | UserId, data: T): void;
-    sendRelay(relayId: string | UserId, receiverId: string | UserId, data: Datagram): void;
+    protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<SendEventData>;
+    sendHandshake(data: KeyExchangeData): Promise<void>;
+    sendHandshake(session: KeySession): Promise<void>;
+    sendHandshake(userId: UserId | string): Promise<void>;
+    sendData<T>(receiverId: string | UserId, data: T): Promise<void>;
+    sendRelay(relayId: string | UserId, receiverId: string | UserId, data: Datagram): Promise<void>;
     packBootstrap(): Datagram;
-    sendBootstrap(receiverId: string | UserId): void;
-    protected decrypt(datagram: EncryptedDatagram | Datagram | Uint8Array): MessageEventData;
-    protected openHandshake(datagram: Datagram | EncryptedDatagram | Uint8Array): 'syn' | 'ack';
-    protected open(datagram: Datagram | EncryptedDatagram | Uint8Array): void;
+    sendBootstrap(receiverId: string | UserId): Promise<void>;
+    protected decrypt(datagram: EncryptedDatagram | Datagram | Uint8Array): Promise<MessageEventData>;
+    protected openHandshake(datagram: Datagram | EncryptedDatagram | Uint8Array): Promise<"syn" | "ack">;
+    protected open(datagram: Datagram | EncryptedDatagram | Uint8Array): Promise<void>;
     toJSON(): FreeSignalNodeState;
 }

package/dist/node.js

@@ -37,7 +37,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _BootstrapRequest_status;
-import { Datagram, decryptData, encryptData, EncryptedDatagram, IdentityKey, Protocols, UserId } from "./types.js";
+import { Datagram, decryptData, encryptData, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types.js";
 import { KeyExchange } from "./x3dh.js";
 import { KeySession } from "./double-ratchet.js";
 import { createIdentity } from "./index.js";
@@ -71,10 +71,8 @@ export class BootstrapRequest extends EventEmitter {
 }
 _BootstrapRequest_status = new WeakMap();
 export class FreeSignalNode {
-    constructor(privateIdentityKey) {
-        this.sessions = new Map();
-        this.users = new Map();
-        this.bundles = new Map();
+    constructor({ privateIdentityKey, sessions, users, bundles, keyExchange } = {}) {
+        var _a;
         this.bootstraps = new Map();
         this.emitter = new EventEmitter();
         this.messageHandler = (data) => this.onMessage({ session: data.session, payload: data.payload });
@@ -87,8 +85,11 @@ export class FreeSignalNode {
         this.onRequest = () => { };
         this.onError = () => { };
         this.onDebug = () => { };
-        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : createIdentity();
-        this.keyExchange = new KeyExchange({ privateIdentityKey: this.privateIdentityKey });
+        this.privateIdentityKey = privateIdentityKey ? PrivateIdentityKey.from(privateIdentityKey) : createIdentity();
+        this.sessions = new Map((_a = sessions === null || sessions === void 0 ? void 0 : sessions.map(([key, value]) => [key, KeySession.from(value)])) !== null && _a !== void 0 ? _a : []);
+        this.users = new Map(users);
+        this.bundles = new Map(bundles);
+        this.keyExchange = new KeyExchange({ privateIdentityKey: this.privateIdentityKey, storage: keyExchange });
         this.emitter.on('message', this.messageHandler);
         this.emitter.on('send', this.sendHandler);
         this.emitter.on('handshake', this.handshakeHandler);
@@ -122,57 +123,65 @@ export class FreeSignalNode {
         return this.identityKey.userId;
     }
     encrypt(receiverId, protocol, data) {
-        try {
-            const sessionTag = this.users.get(receiverId.toString());
-            if (!sessionTag)
-                throw new Error("User not found: " + receiverId);
-            const session = this.sessions.get(sessionTag);
-            if (!session)
-                throw new Error("Session not found for sessionTag: " + sessionTag);
-            const encrypted = encryptData(session, data);
-            this.sessions.set(receiverId.toString(), session);
-            return { session, userId: UserId.from(receiverId), datagram: new EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
-        }
-        catch (error) {
-            this.error(error);
-            throw error;
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const sessionTag = this.users.get(receiverId.toString());
+                if (!sessionTag)
+                    throw new Error("User not found: " + receiverId);
+                const session = this.sessions.get(sessionTag);
+                if (!session)
+                    throw new Error("Session not found for sessionTag: " + sessionTag);
+                const encrypted = encryptData(session, data);
+                this.sessions.set(receiverId.toString(), session);
+                return { session, userId: UserId.from(receiverId), datagram: new EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
+        });
     }
     sendHandshake(data) {
-        try {
-            if (data instanceof UserId || typeof data === 'string') {
-                const session = this.sessions.get(data.toString());
-                if (!session)
-                    throw new Error("Session not found for userId: " + data.toString());
-                data = session;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (data instanceof UserId || typeof data === 'string') {
+                    const session = this.sessions.get(data.toString());
+                    if (!session)
+                        throw new Error("Session not found for userId: " + data.toString());
+                    data = session;
+                }
+                if (data instanceof KeySession) {
+                    //console.debug("Sending Handshake Ack");
+                    const session = this.sessions.get(data.sessionTag);
+                    if (!session)
+                        throw new Error("Session not found for sessionTag: " + data.sessionTag);
+                    this.emitter.emit('send', yield this.encrypt(session.userId, Protocols.HANDSHAKE, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
+                    return;
+                }
             }
-            if (data instanceof KeySession) {
-                //console.debug("Sending Handshake Ack");
-                const session = this.sessions.get(data.sessionTag);
-                if (!session)
-                    throw new Error("Session not found for sessionTag: " + data.sessionTag);
-                this.emitter.emit('send', this.encrypt(session.userId, Protocols.HANDSHAKE, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
-                return;
+            catch (error) {
+                this.error(error);
+                throw error;
             }
-        }
-        catch (error) {
-            this.error(error);
-            throw error;
-        }
-        //console.debug("Sending Handshake Syn");
-        const { session, message } = this.keyExchange.digestData(data, encodeData(this.keyExchange.generateBundle()));
-        this.sessions.set(session.sessionTag, session);
-        this.users.set(session.userId.toString(), session.sessionTag);
-        const datagram = new Datagram(Protocols.HANDSHAKE, encodeData(message), session.sessionTag).sign(this.privateIdentityKey.signatureKey);
-        this.emitter.emit('send', { session, datagram, userId: session.userId });
+            //console.debug("Sending Handshake Syn");
+            const { session, message } = this.keyExchange.digestData(data, encodeData(this.keyExchange.generateBundle()));
+            this.sessions.set(session.sessionTag, session);
+            this.users.set(session.userId.toString(), session.sessionTag);
+            const datagram = new Datagram(Protocols.HANDSHAKE, encodeData(message), session.sessionTag).sign(this.privateIdentityKey.signatureKey);
+            this.emitter.emit('send', { session, datagram, userId: session.userId });
+        });
     }
     sendData(receiverId, data) {
-        //console.debug("Sending Data");
-        this.emitter.emit('send', this.encrypt(receiverId, Protocols.MESSAGE, encodeData(data)));
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Sending Data");
+            this.emitter.emit('send', yield this.encrypt(receiverId, Protocols.MESSAGE, encodeData(data)));
+        });
     }
     sendRelay(relayId, receiverId, data) {
-        //console.debug("Sending Relay");
-        this.emitter.emit('send', this.encrypt(relayId, Protocols.RELAY, concatBytes(UserId.from(receiverId).toBytes(), data.toBytes())));
+        return __awaiter(this, void 0, void 0, function* () {
+            //console.debug("Sending Relay");
+            this.emitter.emit('send', yield this.encrypt(relayId, Protocols.RELAY, concatBytes(UserId.from(receiverId).toBytes(), data.toBytes())));
+        });
     }
     /*public async sendPing(receiverId: string | UserId): Promise<void> {
         //console.debug("Sending Ping");
@@ -203,173 +212,181 @@ export class FreeSignalNode {
         return new Datagram(Protocols.BOOTSTRAP, encodeData(this.keyExchange.generateData()));
     }
     sendBootstrap(receiverId) {
-        try {
-            //console.debug("Sending Bootstrap");
-            if (this.sessions.has(receiverId.toString()))
-                throw new Error("Session exists");
-            const datagram = this.packBootstrap();
-            this.emitter.emit('send', { datagram, userId: UserId.from(receiverId) });
-        }
-        catch (error) {
-            this.error(error);
-            throw error;
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                //console.debug("Sending Bootstrap");
+                if (this.sessions.has(receiverId.toString()))
+                    throw new Error("Session exists");
+                const datagram = this.packBootstrap();
+                this.emitter.emit('send', { datagram, userId: UserId.from(receiverId) });
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
+        });
     }
     decrypt(datagram) {
-        try {
-            datagram = EncryptedDatagram.from(datagram);
-            if (!datagram.sessionTag)
-                throw new Error("Datagram not encrypted");
-            const session = this.sessions.get(datagram.sessionTag);
-            if (!session)
-                throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-            if (!datagram.verify(session.identityKey.signatureKey))
-                throw new Error("Signature not verified");
-            if (!datagram.payload)
-                throw new Error("Missing payload");
-            const decrypted = decryptData(session, datagram.payload);
-            this.sessions.set(datagram.sessionTag, session);
-            return { session, payload: decrypted };
-        }
-        catch (error) {
-            this.error(error);
-            throw error;
-        }
-    }
-    openHandshake(datagram) {
-        try {
-            const encrypted = EncryptedDatagram.from(datagram);
-            if (!encrypted.payload)
-                throw new Error("Missing payload");
-            if (this.sessions.has(encrypted.sessionTag)) {
-                //console.debug("Opening Handshake Ack");
-                const session = this.sessions.get(encrypted.sessionTag);
-                const { payload } = this.decrypt(encrypted);
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                datagram = EncryptedDatagram.from(datagram);
+                if (!datagram.sessionTag)
+                    throw new Error("Datagram not encrypted");
+                const session = this.sessions.get(datagram.sessionTag);
                 if (!session)
-                    throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
-                if (!compareBytes(payload, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
-                    throw new Error("Error validating handshake data");
-                return 'ack';
+                    throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                if (!datagram.verify(session.identityKey.signatureKey))
+                    throw new Error("Signature not verified");
+                if (!datagram.payload)
+                    throw new Error("Missing payload");
+                const decrypted = decryptData(session, datagram.payload);
+                this.sessions.set(datagram.sessionTag, session);
+                return { session, payload: decrypted };
             }
-            //console.debug("Opening Handshake Syn");
-            const data = decodeData(encrypted.payload);
-            if (!encrypted.verify(IdentityKey.from(data.identityKey).signatureKey))
-                throw new Error("Signature not verified");
-            const { session, associatedData } = this.keyExchange.digestMessage(data);
-            this.sessions.set(session.sessionTag, session);
-            this.users.set(session.userId.toString(), session.sessionTag);
-            this.bundles.set(session.userId.toString(), decodeData(associatedData));
-            return 'syn';
-        }
-        catch (error) {
-            this.error(error);
-            throw error;
-        }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
+        });
     }
-    open(datagram) {
-        try {
-            if (datagram instanceof Uint8Array)
-                datagram = Datagram.from(datagram);
-            switch (datagram.protocol) {
-                case Protocols.HANDSHAKE: {
-                    const encrypted = EncryptedDatagram.from(datagram);
-                    if (!encrypted.payload)
-                        throw new Error("Missing payload");
-                    const handshakeState = this.openHandshake(datagram);
+    openHandshake(datagram) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const encrypted = EncryptedDatagram.from(datagram);
+                if (!encrypted.payload)
+                    throw new Error("Missing payload");
+                if (this.sessions.has(encrypted.sessionTag)) {
+                    //console.debug("Opening Handshake Ack");
                     const session = this.sessions.get(encrypted.sessionTag);
+                    const { payload } = yield this.decrypt(encrypted);
                     if (!session)
                         throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
-                    if (handshakeState === 'syn')
-                        this.sendHandshake(session);
-                    this.emitter.emit('handshake', { session });
-                    return;
-                }
-                case Protocols.MESSAGE:
-                    //console.debug("Opening Message");
-                    this.emitter.emit('message', this.decrypt(datagram));
-                    return;
-                case Protocols.RELAY: {
-                    //console.debug("Opening Relay");
-                    const opened = this.decrypt(datagram);
-                    const userId = decodeBase64(opened.payload.subarray(0, UserId.keyLength));
-                    const sessionTag = this.users.get(userId);
-                    if (!sessionTag)
-                        throw new Error("Session not found for user: " + userId);
-                    const session = this.sessions.get(sessionTag);
-                    if (!session)
-                        throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-                    this.emitter.emit('send', { session, datagram: Datagram.from(opened.payload.slice(UserId.keyLength)), userId: session.userId });
-                    return;
-                }
-                case Protocols.BOOTSTRAP: {
-                    //console.debug("Opening Bootstrap");
-                    if (!datagram.payload)
-                        throw new Error("Invalid Bootstrap");
-                    const keyExchangeData = decodeData(datagram.payload);
-                    const userId = UserId.fromKey(keyExchangeData.identityKey);
-                    const request = new BootstrapRequest(userId, keyExchangeData);
-                    let sended = false;
-                    request.onChange = (request) => {
-                        if (request.status === 'accepted' && !sended) {
-                            sended = true;
-                            this.sendHandshake(request.data);
-                        }
-                    };
-                    this.bootstraps.set(userId.toString(), request);
-                    this.emitter.emit('bootstrap', { request });
-                    return;
+                    if (!compareBytes(payload, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
+                        throw new Error("Error validating handshake data");
+                    return 'ack';
                 }
-                /*case Protocols.DISCOVER: {
-                    //console.debug("Opening Discover");
-                    const { session, payload } = await this.decrypt(datagram);
-                    const message = decodeData<DiscoverMessage>(payload);
-                    if (message.type === DiscoverType.REQUEST && message.discoverId && !(await this.sessions.has(message.discoverId))) {
-                        let data: KeyExchangeData;
-                        if (message.discoverId === this.userId.toString()) {
-                            data = await this.keyExchange.generateData();
-                        } else {
-                            const bundle = await this.bundles.get(message.discoverId);
-                            if (!bundle)
-                                return;
-                            const { version, identityKey, signedPreKey, signature } = bundle;
-                            const onetimePreKey = bundle.onetimePreKeys.shift();
-                            if (!onetimePreKey) {
-                                await this.bundles.delete(message.discoverId);
-                                return;
+                //console.debug("Opening Handshake Syn");
+                const data = decodeData(encrypted.payload);
+                if (!encrypted.verify(IdentityKey.from(data.identityKey).signatureKey))
+                    throw new Error("Signature not verified");
+                const { session, associatedData } = this.keyExchange.digestMessage(data);
+                this.sessions.set(session.sessionTag, session);
+                this.users.set(session.userId.toString(), session.sessionTag);
+                this.bundles.set(session.userId.toString(), decodeData(associatedData));
+                return 'syn';
+            }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
+        });
+    }
+    open(datagram) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (datagram instanceof Uint8Array)
+                    datagram = Datagram.from(datagram);
+                switch (datagram.protocol) {
+                    case Protocols.HANDSHAKE: {
+                        const encrypted = EncryptedDatagram.from(datagram);
+                        if (!encrypted.payload)
+                            throw new Error("Missing payload");
+                        const handshakeState = yield this.openHandshake(datagram);
+                        const session = this.sessions.get(encrypted.sessionTag);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
+                        if (handshakeState === 'syn')
+                            this.sendHandshake(session);
+                        this.emitter.emit('handshake', { session });
+                        return;
+                    }
+                    case Protocols.MESSAGE:
+                        //console.debug("Opening Message");
+                        this.emitter.emit('message', yield this.decrypt(datagram));
+                        return;
+                    case Protocols.RELAY: {
+                        //console.debug("Opening Relay");
+                        const opened = yield this.decrypt(datagram);
+                        const userId = decodeBase64(opened.payload.subarray(0, UserId.keyLength));
+                        const sessionTag = this.users.get(userId);
+                        if (!sessionTag)
+                            throw new Error("Session not found for user: " + userId);
+                        const session = this.sessions.get(sessionTag);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                        this.emitter.emit('send', { session, datagram: Datagram.from(opened.payload.slice(UserId.keyLength)), userId: session.userId });
+                        return;
+                    }
+                    case Protocols.BOOTSTRAP: {
+                        //console.debug("Opening Bootstrap");
+                        if (!datagram.payload)
+                            throw new Error("Invalid Bootstrap");
+                        const keyExchangeData = decodeData(datagram.payload);
+                        const userId = UserId.fromKey(keyExchangeData.identityKey);
+                        const request = new BootstrapRequest(userId, keyExchangeData);
+                        let sended = false;
+                        request.onChange = (request) => {
+                            if (request.status === 'accepted' && !sended) {
+                                sended = true;
+                                this.sendHandshake(request.data);
                             }
-                            data = {
-                                version,
-                                identityKey,
-                                signedPreKey,
-                                signature,
-                                onetimePreKey
-                            };
+                        };
+                        this.bootstraps.set(userId.toString(), request);
+                        this.emitter.emit('bootstrap', { request });
+                        return;
+                    }
+                    /*case Protocols.DISCOVER: {
+                        //console.debug("Opening Discover");
+                        const { session, payload } = await this.decrypt(datagram);
+                        const message = decodeData<DiscoverMessage>(payload);
+                        if (message.type === DiscoverType.REQUEST && message.discoverId && !(await this.sessions.has(message.discoverId))) {
+                            let data: KeyExchangeData;
+                            if (message.discoverId === this.userId.toString()) {
+                                data = await this.keyExchange.generateData();
+                            } else {
+                                const bundle = await this.bundles.get(message.discoverId);
+                                if (!bundle)
+                                    return;
+                                const { version, identityKey, signedPreKey, signature } = bundle;
+                                const onetimePreKey = bundle.onetimePreKeys.shift();
+                                if (!onetimePreKey) {
+                                    await this.bundles.delete(message.discoverId);
+                                    return;
+                                }
+                                data = {
+                                    version,
+                                    identityKey,
+                                    signedPreKey,
+                                    signature,
+                                    onetimePreKey
+                                };
+                            }
+                            const response: DiscoverMessage = { type: DiscoverType.RESPONSE, discoverId: message.discoverId, data };
+                            this.emitter.emit('send', await this.encrypt(session.userId, Protocols.DISCOVER, encodeData(response)));
+                        } else if (message.type === DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
+                            this.discovers.delete(message.discoverId);
+                            if (message.data)
+                                await this.sendHandshake(message.data);
                         }
-                        const response: DiscoverMessage = { type: DiscoverType.RESPONSE, discoverId: message.discoverId, data };
-                        this.emitter.emit('send', await this.encrypt(session.userId, Protocols.DISCOVER, encodeData(response)));
-                    } else if (message.type === DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
-                        this.discovers.delete(message.discoverId);
-                        if (message.data)
-                            await this.sendHandshake(message.data);
+                        return;
                     }
-                    return;
+        
+                    case Protocols.PING:
+                        datagram = EncryptedDatagram.from(datagram);
+                        const session = await this.sessions.get(datagram.sessionTag!);
+                        if (!session)
+                            throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
+                        this.emitter.emit('ping', { session });
+                        return;*/
+                    default:
+                        throw new Error("Invalid protocol");
                 }
-    
-                case Protocols.PING:
-                    datagram = EncryptedDatagram.from(datagram);
-                    const session = await this.sessions.get(datagram.sessionTag!);
-                    if (!session)
-                        throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-                    this.emitter.emit('ping', { session });
-                    return;*/
-                default:
-                    throw new Error("Invalid protocol");
             }
-        }
-        catch (error) {
-            this.error(error);
-            throw error;
-        }
+            catch (error) {
+                this.error(error);
+                throw error;
+            }
+        });
     }
     toJSON() {
         return {
@@ -377,7 +394,7 @@ export class FreeSignalNode {
             sessions: Array.from(this.sessions.entries()).map(([key, session]) => [key, session.toJSON()]),
             users: Array.from(this.users.entries()),
             bundles: Array.from(this.bundles),
-            keyExchange: this.keyExchange.toJSON(),
+            keyExchange: this.keyExchange.toJSON().storage,
         };
     }
 }

package/dist/x3dh.d.ts

@@ -29,10 +29,7 @@ export declare class KeyExchange {
     private static readonly maxOPK;
     private readonly privateIdentityKey;
     private readonly storage;
-    constructor({ storage, privateIdentityKey }: {
-        storage?: Array<[string, Crypto.KeyPair]>;
-        privateIdentityKey?: PrivateIdentityKey;
-    });
+    constructor({ storage, privateIdentityKey }?: Partial<KeyExchangeState>);
     get identityKey(): IdentityKey;
     private generateSPK;
     private generateOPK;

package/dist/x3dh.js

@@ -22,7 +22,7 @@ import { concatBytes, decodeBase64, encodeBase64, compareBytes } from "@freesign
 import { decryptData, encryptData, IdentityKey } from "./types.js";
 import { createIdentity } from "./index.js";
 export class KeyExchange {
-    constructor({ storage, privateIdentityKey }) {
+    constructor({ storage, privateIdentityKey } = {}) {
         this.storage = new Map(storage);
         this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : createIdentity();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesignal/protocol",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Signal Protocol implementation in TypeScript",
   "license": "GPL-3.0-or-later",
   "author": "Christian Braghette",