@freesignal/protocol 0.7.11 → 0.8.1

package/dist/double-ratchet.d.ts

@@ -16,7 +16,7 @@
  * 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 { IdentityKey, UserId } from "./types";
+import { IdentityKey, UserId } from "./types.js";
 export interface ExportedKeySession {
     identityKey: string;
     secretKey: string;

package/dist/double-ratchet.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * FreeSignal Protocol
  *
@@ -17,31 +16,26 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeySession = void 0;
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
-const utils_1 = require("@freesignal/utils");
-const types_1 = require("./types");
+import crypto from "@freesignal/crypto";
+import { decodeBase64, encodeBase64, compareBytes } from "@freesignal/utils";
+import { IdentityKey } from "./types.js";
 /**
  * Represents a secure Double Ratchet session.
  * Used for forward-secure encryption and decryption of messages.
  */
-class KeySession {
+export class KeySession {
     constructor({ identityKey, secretKey, remoteKey, rootKey, headerKey, nextHeaderKey }) {
         this.headerKeys = new Map();
         this.previousKeys = new KeyMap();
         this.identityKey = identityKey;
         this.rootKey = rootKey;
-        this.sessionTag = (0, utils_1.decodeBase64)(crypto_1.default.hkdf(rootKey, new Uint8Array(32).fill(0), "/freesignal/session-authtag", 32));
-        this.keyPair = crypto_1.default.ECDH.keyPair(secretKey);
+        this.sessionTag = decodeBase64(crypto.hkdf(rootKey, new Uint8Array(32).fill(0), "/freesignal/session-authtag", 32));
+        this.keyPair = crypto.ECDH.keyPair(secretKey);
         if (headerKey)
             this.headerKey = headerKey;
         if (nextHeaderKey) {
             this.nextHeaderKey = nextHeaderKey;
-            this.headerKeys.set((0, utils_1.decodeBase64)(crypto_1.default.hash(nextHeaderKey)), nextHeaderKey);
+            this.headerKeys.set(decodeBase64(crypto.hash(nextHeaderKey)), nextHeaderKey);
         }
         if (remoteKey) {
             this.sendingChain = this.getChain(remoteKey, this.headerKey);
@@ -52,10 +46,10 @@ class KeySession {
         return this.identityKey.userId;
     }
     getChain(remoteKey, headerKey, previousCount) {
-        const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, remoteKey);
+        const sharedKey = crypto.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 = crypto.hash(sharedKey);
+        const hashkey = crypto.hkdf(sharedKey, this.rootKey, KeySession.info, KeySession.keyLength * 3);
         this.rootKey = hashkey.subarray(0, KeySession.keyLength);
         return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength, KeySession.keyLength * 2), hashkey.subarray(KeySession.keyLength * 2), headerKey, previousCount);
     }
@@ -79,17 +73,17 @@ class KeySession {
     }
     getReceivingKey(encryptionKeys) {
         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())) {
+        if (!this.previousKeys.has(decodeBase64(encryptionKeys.publicKey) + encryptionKeys.count.toString())) {
+            if (!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.previousKeys.set(decodeBase64(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
                 }
                 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);
+                this.headerKeys.set(decodeBase64(crypto.hash(this.receivingChain.nextHeaderKey)), this.receivingChain.nextHeaderKey);
                 if (this.nextHeaderKey)
                     this.nextHeaderKey = undefined;
-                this.keyPair = crypto_1.default.ECDH.keyPair();
+                this.keyPair = crypto.ECDH.keyPair();
                 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;
@@ -98,10 +92,10 @@ class KeySession {
                 throw new Error("Error initializing receivingChain");
             while (this.receivingChain.count < encryptionKeys.count) {
                 const key = this.receivingChain.getKey();
-                this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
+                this.previousKeys.set(decodeBase64(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
             }
         }
-        return this.previousKeys.get((0, utils_1.decodeBase64)(encryptionKeys.publicKey) + encryptionKeys.count.toString());
+        return this.previousKeys.get(decodeBase64(encryptionKeys.publicKey) + encryptionKeys.count.toString());
     }
     /**
      * Whether both the sending and receiving chains are initialized.
@@ -118,11 +112,11 @@ class KeySession {
         var _a, _b;
         return {
             identityKey: this.identityKey.toString(),
-            secretKey: (0, utils_1.decodeBase64)(this.keyPair.secretKey),
-            rootKey: (0, utils_1.decodeBase64)(this.rootKey),
+            secretKey: decodeBase64(this.keyPair.secretKey),
+            rootKey: 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,
+            headerKey: this.headerKey ? decodeBase64(this.headerKey) : undefined,
             headerKeys: Array.from(this.headerKeys.entries()),
             previousKeys: Array.from(this.previousKeys.entries())
         };
@@ -134,14 +128,13 @@ 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: (0, utils_1.encodeBase64)(data.rootKey) });
+        const session = new KeySession({ identityKey: IdentityKey.from(data.identityKey), secretKey: encodeBase64(data.secretKey), rootKey: 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);
         return session;
     }
 }
-exports.KeySession = KeySession;
 KeySession.keyLength = 32;
 KeySession.version = 1;
 KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
@@ -159,7 +152,7 @@ class KeyChain {
     getKey() {
         if (++this._count >= KeySession.maxCount)
             throw new Error("SendingChain count too big");
-        const hash = crypto_1.default.hkdf(this.chainKey, new Uint8Array(KeySession.keyLength).fill(0), KeySession.info, KeySession.keyLength * 2);
+        const hash = crypto.hkdf(this.chainKey, new Uint8Array(KeySession.keyLength).fill(0), KeySession.info, KeySession.keyLength * 2);
         this.chainKey = hash.subarray(0, KeySession.keyLength);
         return hash.subarray(KeySession.keyLength);
     }
@@ -171,18 +164,18 @@ class KeyChain {
     }
     toJSON() {
         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),
+            publicKey: decodeBase64(this.publicKey),
+            remoteKey: decodeBase64(this.remoteKey),
+            headerKey: this.headerKey ? decodeBase64(this.headerKey) : undefined,
+            nextHeaderKey: decodeBase64(this.nextHeaderKey),
+            chainKey: decodeBase64(this.chainKey),
             count: this.count,
             previousCount: this.previousCount
         };
     }
     static from(obj) {
         //
-        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), (0, utils_1.encodeBase64)(obj.nextHeaderKey), obj.headerKey ? (0, utils_1.encodeBase64)(obj.headerKey) : undefined, obj.previousCount);
+        const chain = new KeyChain(encodeBase64(obj.publicKey), encodeBase64(obj.remoteKey), encodeBase64(obj.chainKey), encodeBase64(obj.nextHeaderKey), obj.headerKey ? encodeBase64(obj.headerKey) : undefined, obj.previousCount);
         chain._count = obj.count;
         return chain;
     }

package/dist/index.d.ts

@@ -17,9 +17,9 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { LocalStorage, Crypto, Database, KeyExchangeDataBundle } from "@freesignal/interfaces";
-import { ExportedKeySession } from "./double-ratchet";
-import { PrivateIdentityKey } from "./types";
-import { BootstrapRequest, FreeSignalNode } from "./node";
+import { ExportedKeySession } from "./double-ratchet.js";
+import { PrivateIdentityKey } from "./types.js";
+import { BootstrapRequest, FreeSignalNode } from "./node.js";
 /**
  * Generates identity key
  *
@@ -35,4 +35,4 @@ export declare function createNode(storage: Database<{
     bundles: LocalStorage<string, KeyExchangeDataBundle>;
     bootstraps: LocalStorage<string, BootstrapRequest>;
 }>, privateIdentityKey?: PrivateIdentityKey): FreeSignalNode;
-export * from "./types";
+export * from "./types.js";

package/dist/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * FreeSignal Protocol
  *
@@ -17,45 +16,26 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIdentity = createIdentity;
-exports.createNode = createNode;
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
-const types_1 = require("./types");
-const node_1 = require("./node");
+import crypto from "@freesignal/crypto";
+import { PrivateIdentityKey } from "./types.js";
+import { FreeSignalNode } from "./node.js";
 /**
  * Generates identity key
  *
  * @param seed - Seed to generate the key.
  * @returns An object containing readonly signing and box key pairs.
  */
-function createIdentity(seed) {
-    seed !== null && seed !== void 0 ? seed : (seed = crypto_1.default.randomBytes(crypto_1.default.EdDSA.seedLength));
-    const signatureSeed = crypto_1.default.hkdf(seed, new Uint8Array(crypto_1.default.EdDSA.seedLength).fill(0), "identity-ed25519", crypto_1.default.EdDSA.seedLength);
-    const exchangeSeed = crypto_1.default.hkdf(seed, new Uint8Array(crypto_1.default.ECDH.secretKeyLength).fill(0), "identity-x25519", crypto_1.default.ECDH.secretKeyLength);
-    const signatureKeyPair = crypto_1.default.EdDSA.keyPairFromSeed(signatureSeed);
-    const exchangeKeyPair = crypto_1.default.ECDH.keyPair(exchangeSeed);
-    return types_1.PrivateIdentityKey.from(signatureKeyPair.secretKey, exchangeKeyPair.secretKey);
+export function createIdentity(seed) {
+    const seedLength = 32;
+    seed !== null && seed !== void 0 ? seed : (seed = crypto.randomBytes(seedLength));
+    const signatureSeed = crypto.hkdf(seed, new Uint8Array(seedLength).fill(0), "identity-ed25519", seedLength);
+    const exchangeSeed = crypto.hkdf(seed, new Uint8Array(crypto.ECDH.secretKeyLength).fill(0), "identity-x25519", crypto.ECDH.secretKeyLength);
+    const signatureKeyPair = crypto.EdDSA.keyPairFromSeed(signatureSeed);
+    const exchangeKeyPair = crypto.ECDH.keyPair(exchangeSeed);
+    return PrivateIdentityKey.from(signatureKeyPair.secretKey, exchangeKeyPair.secretKey);
 }
 /** */
-function createNode(storage, privateIdentityKey) {
-    return new node_1.FreeSignalNode(storage, privateIdentityKey);
+export function createNode(storage, privateIdentityKey) {
+    return new FreeSignalNode(storage, privateIdentityKey);
 }
-__exportStar(require("./types"), exports);
+export * from "./types.js";

package/dist/node.d.ts

@@ -17,10 +17,10 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
-import { Datagram, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
-import { KeyExchange } from "./x3dh";
-import { ExportedKeySession, KeySession } from "./double-ratchet";
-import EventEmitter, { EventCallback } from "easyemitter.ts";
+import { Datagram, EncryptedDatagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types.js";
+import { KeyExchange } from "./x3dh.js";
+import { ExportedKeySession, KeySession } from "./double-ratchet.js";
+import { EventEmitter, EventCallback } from "easyemitter.ts";
 export declare class BootstrapRequest extends EventEmitter<'change', BootstrapRequest> {
     #private;
     readonly senderId: UserId | string;
@@ -81,6 +81,7 @@ export declare class FreeSignalNode {
     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>;
     sendPing(receiverId: string | UserId): Promise<void>;

package/dist/node.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * FreeSignal Protocol
  *
@@ -37,20 +36,15 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 var _BootstrapRequest_status;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreeSignalNode = exports.BootstrapRequest = void 0;
-const types_1 = require("./types");
-const x3dh_1 = require("./x3dh");
-const double_ratchet_1 = require("./double-ratchet");
-const _1 = require(".");
-const utils_1 = require("@freesignal/utils");
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
-const easyemitter_ts_1 = __importDefault(require("easyemitter.ts"));
-class BootstrapRequest extends easyemitter_ts_1.default {
+import { Datagram, decryptData, DiscoverType, encryptData, EncryptedDatagram, IdentityKey, Protocols, UserId } from "./types.js";
+import { KeyExchange } from "./x3dh.js";
+import { KeySession } from "./double-ratchet.js";
+import { createIdentity } from "./index.js";
+import { decodeData, encodeData, compareBytes, concatBytes, decodeBase64 } from "@freesignal/utils";
+import crypto from "@freesignal/crypto";
+import { EventEmitter } from "easyemitter.ts";
+export class BootstrapRequest extends EventEmitter {
     constructor(senderId, data) {
         super();
         this.senderId = senderId;
@@ -75,24 +69,23 @@ class BootstrapRequest extends easyemitter_ts_1.default {
         }
     }
 }
-exports.BootstrapRequest = BootstrapRequest;
 _BootstrapRequest_status = new WeakMap();
-class FreeSignalNode {
+export class FreeSignalNode {
     constructor(storage, privateIdentityKey) {
         this.discovers = new Set();
-        this.emitter = new easyemitter_ts_1.default();
+        this.emitter = new EventEmitter();
         this.messageHandler = (data) => this.onMessage({ session: data.session, payload: data.payload });
         this.sendHandler = (data) => this.onSend(data.datagram.toBytes());
-        this.handshakeHandler = (data) => { var _a; return this.onHandshake(types_1.UserId.from((_a = data.session) === null || _a === void 0 ? void 0 : _a.userId)); };
+        this.handshakeHandler = (data) => { var _a; return this.onHandshake(UserId.from((_a = data.session) === null || _a === void 0 ? void 0 : _a.userId)); };
         this.bootstrapHandler = (data) => this.onRequest(data.request);
         this.onMessage = () => { };
         this.onSend = () => { };
         this.onHandshake = () => { };
         this.onRequest = () => { };
-        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
+        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : createIdentity();
         this.sessions = new SessionMap(storage.sessions);
         this.users = storage.users;
-        this.keyExchange = new x3dh_1.KeyExchange(storage.keyExchange, this.privateIdentityKey);
+        this.keyExchange = new KeyExchange(storage.keyExchange, this.privateIdentityKey);
         this.bundles = storage.bundles;
         this.bootstraps = storage.bootstraps;
         this.emitter.on('message', this.messageHandler);
@@ -126,39 +119,45 @@ class FreeSignalNode {
             const session = yield this.sessions.get(sessionTag);
             if (!session)
                 throw new Error("Session not found for sessionTag: " + sessionTag);
-            const encrypted = (0, types_1.encryptData)(session, data);
+            const encrypted = encryptData(session, data);
             this.sessions.set(receiverId.toString(), session);
-            return { session, userId: types_1.UserId.from(receiverId), datagram: new types_1.EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
+            return { session, userId: UserId.from(receiverId), datagram: new EncryptedDatagram(protocol, session.sessionTag, encrypted).sign(this.privateIdentityKey.signatureKey) };
         });
     }
     sendHandshake(data) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (data instanceof double_ratchet_1.KeySession) {
+            if (data instanceof UserId || typeof data === 'string') {
+                const session = yield 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 = yield 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, types_1.Protocols.HANDSHAKE, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
+                this.emitter.emit('send', yield this.encrypt(session.userId, Protocols.HANDSHAKE, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)));
                 return;
             }
             //console.debug("Sending Handshake Syn");
-            const { session, message } = yield this.keyExchange.digestData(data, (0, utils_1.encodeData)(yield this.keyExchange.generateBundle()));
+            const { session, message } = yield this.keyExchange.digestData(data, encodeData(yield this.keyExchange.generateBundle()));
             yield this.sessions.set(session.sessionTag, session);
             yield this.users.set(session.userId.toString(), session.sessionTag);
-            const datagram = new types_1.Datagram(types_1.Protocols.HANDSHAKE, (0, utils_1.encodeData)(message), session.sessionTag).sign(this.privateIdentityKey.signatureKey);
+            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) {
         return __awaiter(this, void 0, void 0, function* () {
             //console.debug("Sending Data");
-            this.emitter.emit('send', yield this.encrypt(receiverId, types_1.Protocols.MESSAGE, (0, utils_1.encodeData)(data)));
+            this.emitter.emit('send', yield this.encrypt(receiverId, Protocols.MESSAGE, encodeData(data)));
         });
     }
     sendRelay(relayId, receiverId, data) {
         return __awaiter(this, void 0, void 0, function* () {
             //console.debug("Sending Relay");
-            this.emitter.emit('send', yield this.encrypt(relayId, types_1.Protocols.RELAY, (0, utils_1.concatBytes)(types_1.UserId.from(receiverId).toBytes(), data.toBytes())));
+            this.emitter.emit('send', yield this.encrypt(relayId, Protocols.RELAY, concatBytes(UserId.from(receiverId).toBytes(), data.toBytes())));
         });
     }
     sendPing(receiverId) {
@@ -170,28 +169,28 @@ class FreeSignalNode {
             const session = yield this.sessions.get(sessionTag);
             if (!session)
                 throw new Error("Session not found for sessionTag: " + sessionTag);
-            const datagram = new types_1.Datagram(types_1.Protocols.PING, undefined, session.sessionTag);
+            const datagram = new Datagram(Protocols.PING, undefined, session.sessionTag);
             this.emitter.emit('send', { session, datagram, userId: session.userId });
         });
     }
     sendDiscover(receiverId, discoverId) {
         return __awaiter(this, void 0, void 0, function* () {
             //console.debug("Sending Discover");
-            if (receiverId instanceof types_1.UserId)
+            if (receiverId instanceof UserId)
                 receiverId = receiverId.toString();
-            if (discoverId instanceof types_1.UserId)
+            if (discoverId instanceof UserId)
                 discoverId = discoverId.toString();
             const message = {
-                type: types_1.DiscoverType.REQUEST,
+                type: DiscoverType.REQUEST,
                 discoverId
             };
             this.discovers.add(receiverId);
-            this.emitter.emit('send', yield this.encrypt(receiverId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(message)));
+            this.emitter.emit('send', yield this.encrypt(receiverId, Protocols.DISCOVER, encodeData(message)));
         });
     }
     packBootstrap() {
         return __awaiter(this, void 0, void 0, function* () {
-            return new types_1.Datagram(types_1.Protocols.BOOTSTRAP, (0, utils_1.encodeData)(yield this.keyExchange.generateData()));
+            return new Datagram(Protocols.BOOTSTRAP, encodeData(yield this.keyExchange.generateData()));
         });
     }
     sendBootstrap(receiverId) {
@@ -200,12 +199,12 @@ class FreeSignalNode {
             if (yield this.sessions.has(receiverId.toString()))
                 throw new Error("Session exists");
             const datagram = yield this.packBootstrap();
-            this.emitter.emit('send', { datagram, userId: types_1.UserId.from(receiverId) });
+            this.emitter.emit('send', { datagram, userId: UserId.from(receiverId) });
         });
     }
     decrypt(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            datagram = types_1.EncryptedDatagram.from(datagram);
+            datagram = EncryptedDatagram.from(datagram);
             if (!datagram.sessionTag)
                 throw new Error("Datagram not encrypted");
             const session = yield this.sessions.get(datagram.sessionTag);
@@ -215,14 +214,14 @@ class FreeSignalNode {
                 throw new Error("Signature not verified");
             if (!datagram.payload)
                 throw new Error("Missing payload");
-            const decrypted = (0, types_1.decryptData)(session, datagram.payload);
+            const decrypted = decryptData(session, datagram.payload);
             this.sessions.set(datagram.sessionTag, session);
             return { session, payload: decrypted };
         });
     }
     openHandshake(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
-            const encrypted = types_1.EncryptedDatagram.from(datagram);
+            const encrypted = EncryptedDatagram.from(datagram);
             if (!encrypted.payload)
                 throw new Error("Missing payload");
             if (yield this.sessions.has(encrypted.sessionTag)) {
@@ -231,28 +230,28 @@ class FreeSignalNode {
                 const { payload } = yield this.decrypt(encrypted);
                 if (!session)
                     throw new Error("Session not found for sessionTag: " + encrypted.sessionTag);
-                if (!(0, utils_1.compareBytes)(payload, crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
+                if (!compareBytes(payload, crypto.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, session.identityKey.exchangeKey)))
                     throw new Error("Error validating handshake data");
                 return 'ack';
             }
             //console.debug("Opening Handshake Syn");
-            const data = (0, utils_1.decodeData)(encrypted.payload);
-            if (!encrypted.verify(types_1.IdentityKey.from(data.identityKey).signatureKey))
+            const data = decodeData(encrypted.payload);
+            if (!encrypted.verify(IdentityKey.from(data.identityKey).signatureKey))
                 throw new Error("Signature not verified");
             const { session, associatedData } = yield this.keyExchange.digestMessage(data);
             yield this.sessions.set(session.sessionTag, session);
             yield this.users.set(session.userId.toString(), session.sessionTag);
-            yield this.bundles.set(session.userId.toString(), (0, utils_1.decodeData)(associatedData));
+            yield this.bundles.set(session.userId.toString(), decodeData(associatedData));
             return 'syn';
         });
     }
     open(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
             if (datagram instanceof Uint8Array)
-                datagram = types_1.Datagram.from(datagram);
+                datagram = Datagram.from(datagram);
             switch (datagram.protocol) {
-                case types_1.Protocols.HANDSHAKE: {
-                    const encrypted = types_1.EncryptedDatagram.from(datagram);
+                case Protocols.HANDSHAKE: {
+                    const encrypted = EncryptedDatagram.from(datagram);
                     if (!encrypted.payload)
                         throw new Error("Missing payload");
                     if ((yield this.openHandshake(datagram)) === 'ack')
@@ -264,28 +263,28 @@ class FreeSignalNode {
                     this.emitter.emit('handshake', { session });
                     return;
                 }
-                case types_1.Protocols.MESSAGE:
+                case Protocols.MESSAGE:
                     //console.debug("Opening Message");
                     this.emitter.emit('message', yield this.decrypt(datagram));
                     return;
-                case types_1.Protocols.RELAY: {
+                case Protocols.RELAY: {
                     //console.debug("Opening Relay");
                     const opened = yield this.decrypt(datagram);
-                    const userId = (0, utils_1.decodeBase64)(opened.payload.subarray(0, types_1.UserId.keyLength));
+                    const userId = decodeBase64(opened.payload.subarray(0, UserId.keyLength));
                     const sessionTag = yield this.users.get(userId);
                     if (!sessionTag)
                         throw new Error("Session not found for user: " + userId);
                     const session = yield this.sessions.get(sessionTag);
                     if (!session)
                         throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
-                    this.emitter.emit('send', { session, datagram: types_1.Datagram.from(opened.payload.slice(types_1.UserId.keyLength)), userId: session.userId });
+                    this.emitter.emit('send', { session, datagram: Datagram.from(opened.payload.slice(UserId.keyLength)), userId: session.userId });
                     return;
                 }
-                case types_1.Protocols.DISCOVER: {
+                case Protocols.DISCOVER: {
                     //console.debug("Opening Discover");
                     const { session, payload } = yield this.decrypt(datagram);
-                    const message = (0, utils_1.decodeData)(payload);
-                    if (message.type === types_1.DiscoverType.REQUEST && message.discoverId && !(yield this.sessions.has(message.discoverId))) {
+                    const message = decodeData(payload);
+                    if (message.type === DiscoverType.REQUEST && message.discoverId && !(yield this.sessions.has(message.discoverId))) {
                         let data;
                         if (message.discoverId === this.userId.toString()) {
                             data = yield this.keyExchange.generateData();
@@ -308,22 +307,22 @@ class FreeSignalNode {
                                 onetimePreKey
                             };
                         }
-                        const response = { type: types_1.DiscoverType.RESPONSE, discoverId: message.discoverId, data };
-                        this.emitter.emit('send', yield this.encrypt(session.userId, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response)));
+                        const response = { type: DiscoverType.RESPONSE, discoverId: message.discoverId, data };
+                        this.emitter.emit('send', yield this.encrypt(session.userId, Protocols.DISCOVER, encodeData(response)));
                     }
-                    else if (message.type === types_1.DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
+                    else if (message.type === DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
                         this.discovers.delete(message.discoverId);
                         if (message.data)
                             yield this.sendHandshake(message.data);
                     }
                     return;
                 }
-                case types_1.Protocols.BOOTSTRAP: {
+                case Protocols.BOOTSTRAP: {
                     //console.debug("Opening Bootstrap");
                     if (!datagram.payload)
                         throw new Error("Invalid Bootstrap");
-                    const keyExchangeData = (0, utils_1.decodeData)(datagram.payload);
-                    const userId = types_1.UserId.fromKey(keyExchangeData.identityKey);
+                    const keyExchangeData = decodeData(datagram.payload);
+                    const userId = UserId.fromKey(keyExchangeData.identityKey);
                     const request = new BootstrapRequest(userId, keyExchangeData);
                     let sended = false;
                     request.onChange = (request) => {
@@ -336,8 +335,8 @@ class FreeSignalNode {
                     this.emitter.emit('bootstrap', { request });
                     return;
                 }
-                case types_1.Protocols.PING:
-                    datagram = types_1.EncryptedDatagram.from(datagram);
+                case Protocols.PING:
+                    datagram = EncryptedDatagram.from(datagram);
                     const session = yield this.sessions.get(datagram.sessionTag);
                     if (!session)
                         throw new Error("Session not found for sessionTag: " + datagram.sessionTag);
@@ -349,7 +348,6 @@ class FreeSignalNode {
         });
     }
 }
-exports.FreeSignalNode = FreeSignalNode;
 class SessionMap {
     constructor(storage, maxSize = 50) {
         this.storage = storage;
@@ -367,7 +365,7 @@ class SessionMap {
                 const sessionData = yield this.storage.get(key);
                 if (!sessionData)
                     return undefined;
-                return double_ratchet_1.KeySession.from(sessionData);
+                return KeySession.from(sessionData);
             }
             return session;
         });

package/dist/types.d.ts

@@ -17,7 +17,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import type { LocalStorage, Encodable, KeyExchangeData } from "@freesignal/interfaces";
-import { EncryptionKeys, KeySession } from "./double-ratchet";
+import { EncryptionKeys, KeySession } from "./double-ratchet.js";
 export declare function encryptData(session: KeySession, data: Uint8Array): EncryptedData;
 export declare function decryptData(session: KeySession, encryptedData: Uint8Array): Uint8Array;
 export declare class UserId implements Encodable {