@freesignal/protocol 0.7.0 → 0.7.1

package/dist/node.d.ts

@@ -36,6 +36,7 @@ type NodeEventData = {
     header: DatagramHeader;
     payload?: Uint8Array;
     datagram?: Datagram;
+    request?: BootstrapRequest;
 };
 type MessageEventData = {
     header: DatagramHeader;
@@ -48,23 +49,25 @@ 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" | "handshaked" | "ping", NodeEventData>;
+    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;
-    onHandshaked: (userId: UserId) => 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;
-    readonly requests: {
-        onRequest: (request: BootstrapRequest) => void;
-        getRequest: (userId: string) => Promise<BootstrapRequest | undefined>;
-    };
     protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
     sendHandshake(data: KeyExchangeData): Promise<void>;
     sendHandshake(receiverId: string | UserId): Promise<void>;

package/dist/node.js

@@ -82,29 +82,33 @@ 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.onHandshaked = () => { };
-        this.requests = {
-            onRequest: () => { },
-            getRequest: (userId) => {
-                return this.bootstraps.get(userId);
-            }
-        };
+        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;
-        this.emitter.on('send', (data) => this.onSend(data.data.datagram.toBytes()));
-        this.emitter.on('handshaked', (data) => this.onHandshaked(types_1.UserId.from(data.data.header.sender)));
+        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;
             if (timeout)
                 setTimeout(() => { throw new Error(); }, timeout);
-            while (((_a = (yield this.emitter.wait('handshaked', timeout))) === null || _a === void 0 ? void 0 : _a.header.sender) !== userId.toString())
+            while (((_a = (yield this.emitter.wait('handshake', timeout))) === null || _a === void 0 ? void 0 : _a.header.sender) !== userId.toString())
                 ;
         });
     }
@@ -186,6 +190,8 @@ class FreeSignalNode {
     sendBootstrap(receiverId) {
         return __awaiter(this, void 0, void 0, function* () {
             //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 });
         });
@@ -225,7 +231,7 @@ 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");
-                        this.emitter.emit('handshaked', { header: datagram.header });
+                        this.emitter.emit('handshake', { header: datagram.header });
                         return;
                     }
                     //console.debug("Opening Handshake Syn");
@@ -236,7 +242,7 @@ class FreeSignalNode {
                     yield this.sessions.set(session.userId.toString(), session);
                     yield this.bundles.set(session.userId.toString(), (0, utils_1.decodeData)(associatedData));
                     yield this.sendHandshake(session.userId);
-                    this.emitter.emit('handshaked', { header: datagram.header });
+                    this.emitter.emit('handshake', { header: datagram.header });
                     return;
                 case types_1.Protocols.MESSAGE:
                     //console.debug("Opening Message");
@@ -295,7 +301,7 @@ class FreeSignalNode {
                         this.sendHandshake(request.data);
                     };
                     yield this.bootstraps.set(datagram.sender, request);
-                    this.requests.onRequest(request);
+                    this.emitter.emit('bootstrap', { header: datagram.header, request });
                     return;
                 case types_1.Protocols.PING:
                     this.emitter.emit('ping', { header: datagram.header });

package/package.json

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