@freesignal/protocol 0.2.8 → 0.2.11

package/x3dh.d.ts

@@ -17,36 +17,35 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, LocalStorage, Crypto } from "@freesignal/interfaces";
-import { KeySession } from "./double-ratchet";
-import { IdentityKeys } from "./types";
+import { ExportedKeySession, KeySession } from "./double-ratchet";
+import { IdentityKey, PrivateIdentityKey } from "./types";
 export interface ExportedKeyExchange {
-    signatureKey: Crypto.KeyPair;
-    identityKey: Crypto.KeyPair;
-    bundleStore: Array<[string, Crypto.KeyPair]>;
+    privateIdentityKey: PrivateIdentityKey;
+    storage: Array<[string, Crypto.KeyPair]>;
 }
 export declare class KeyExchange {
     static readonly version = 1;
     private static readonly hkdfInfo;
     private static readonly maxOPK;
-    private readonly _signatureKey;
-    private readonly _identityKey;
-    private readonly bundleStore;
-    constructor(signSecretKey: Uint8Array, boxSecretKey: Uint8Array, bundleStore?: LocalStorage<string, Crypto.KeyPair>);
-    get signatureKey(): Uint8Array;
-    get identityKey(): Uint8Array;
+    private readonly privateIdentityKey;
+    private readonly storage;
+    private readonly sessions;
+    constructor(storage: {
+        keys: LocalStorage<string, Crypto.KeyPair>;
+        sessions: LocalStorage<string, ExportedKeySession>;
+    }, privateIdentityKey?: PrivateIdentityKey);
+    get identityKey(): IdentityKey;
     private generateSPK;
     private generateOPK;
-    generateBundle(length?: number): KeyExchangeDataBundle;
-    generateData(): KeyExchangeData;
-    digestData(message: KeyExchangeData): {
+    generateBundle(length?: number): Promise<KeyExchangeDataBundle>;
+    generateData(): Promise<KeyExchangeData>;
+    digestData(message: KeyExchangeData): Promise<{
         session: KeySession;
         message: KeyExchangeSynMessage;
-        identityKeys: IdentityKeys;
-    };
+        identityKey: IdentityKey;
+    }>;
     digestMessage(message: KeyExchangeSynMessage): Promise<{
         session: KeySession;
-        identityKeys: IdentityKeys;
+        identityKey: IdentityKey;
     }>;
-    toJSON(): ExportedKeyExchange;
-    static from(data: ExportedKeyExchange): KeyExchange;
 }

package/x3dh.js

@@ -34,159 +34,120 @@ exports.KeyExchange = void 0;
 const crypto_1 = __importDefault(require("@freesignal/crypto"));
 const double_ratchet_1 = require("./double-ratchet");
 const utils_1 = require("@freesignal/utils");
+const types_1 = require("./types");
+const _1 = require(".");
 class KeyExchange {
-    constructor(signSecretKey, boxSecretKey, bundleStore) {
-        this._signatureKey = crypto_1.default.EdDSA.keyPair(signSecretKey);
-        this._identityKey = crypto_1.default.ECDH.keyPair(boxSecretKey);
-        this.bundleStore = bundleStore !== null && bundleStore !== void 0 ? bundleStore : new AsyncMap();
+    constructor(storage, privateIdentityKey) {
+        this.storage = storage.keys;
+        this.sessions = storage.sessions;
+        this.privateIdentityKey = privateIdentityKey !== null && privateIdentityKey !== void 0 ? privateIdentityKey : (0, _1.createIdentity)();
+    }
+    get identityKey() {
+        return this.privateIdentityKey.identityKey;
     }
-    get signatureKey() { return this._signatureKey.publicKey; }
-    get identityKey() { return this._identityKey.publicKey; }
     generateSPK() {
         const signedPreKey = crypto_1.default.ECDH.keyPair();
         const signedPreKeyHash = crypto_1.default.hash(signedPreKey.publicKey);
-        this.bundleStore.set((0, utils_1.decodeBase64)(signedPreKeyHash), signedPreKey);
+        this.storage.set((0, utils_1.decodeBase64)(signedPreKeyHash), signedPreKey);
         return { signedPreKey, signedPreKeyHash };
     }
     generateOPK(spkHash) {
         const onetimePreKey = crypto_1.default.ECDH.keyPair();
         const onetimePreKeyHash = crypto_1.default.hash(onetimePreKey.publicKey);
-        this.bundleStore.set((0, utils_1.decodeBase64)(spkHash).concat((0, utils_1.decodeBase64)(onetimePreKeyHash)), onetimePreKey);
+        this.storage.set((0, utils_1.decodeBase64)(spkHash).concat((0, utils_1.decodeBase64)(onetimePreKeyHash)), onetimePreKey);
         return { onetimePreKey, onetimePreKeyHash };
     }
     generateBundle(length) {
-        const { signedPreKey, signedPreKeyHash } = this.generateSPK();
-        const onetimePreKey = new Array(length !== null && length !== void 0 ? length : KeyExchange.maxOPK).fill(0).map(() => this.generateOPK(signedPreKeyHash).onetimePreKey);
-        return {
-            version: KeyExchange.version,
-            publicKey: (0, utils_1.decodeBase64)(this._signatureKey.publicKey),
-            identityKey: (0, utils_1.decodeBase64)(this._identityKey.publicKey),
-            signedPreKey: (0, utils_1.decodeBase64)(signedPreKey.publicKey),
-            signature: (0, utils_1.decodeBase64)(crypto_1.default.EdDSA.sign(signedPreKeyHash, this._signatureKey.secretKey)),
-            onetimePreKey: onetimePreKey.map(opk => (0, utils_1.decodeBase64)(opk.publicKey))
-        };
+        return __awaiter(this, void 0, void 0, function* () {
+            const { signedPreKey, signedPreKeyHash } = this.generateSPK();
+            const onetimePreKey = new Array(length !== null && length !== void 0 ? length : KeyExchange.maxOPK).fill(0).map(() => this.generateOPK(signedPreKeyHash).onetimePreKey);
+            return {
+                version: KeyExchange.version,
+                identityKey: this.identityKey.toString(),
+                signedPreKey: (0, utils_1.decodeBase64)(signedPreKey.publicKey),
+                signature: (0, utils_1.decodeBase64)(crypto_1.default.EdDSA.sign(signedPreKeyHash, this.privateIdentityKey.signatureKey)),
+                onetimePreKey: onetimePreKey.map(opk => (0, utils_1.decodeBase64)(opk.publicKey))
+            };
+        });
     }
     generateData() {
-        const { signedPreKey, signedPreKeyHash } = this.generateSPK();
-        const { onetimePreKey } = this.generateOPK(signedPreKeyHash);
-        return {
-            version: KeyExchange.version,
-            publicKey: (0, utils_1.decodeBase64)(this._signatureKey.publicKey),
-            identityKey: (0, utils_1.decodeBase64)(this._identityKey.publicKey),
-            signedPreKey: (0, utils_1.decodeBase64)(signedPreKey.publicKey),
-            signature: (0, utils_1.decodeBase64)(crypto_1.default.EdDSA.sign(signedPreKeyHash, this._signatureKey.secretKey)),
-            onetimePreKey: (0, utils_1.decodeBase64)(onetimePreKey.publicKey)
-        };
+        return __awaiter(this, void 0, void 0, function* () {
+            const { signedPreKey, signedPreKeyHash } = this.generateSPK();
+            const { onetimePreKey } = this.generateOPK(signedPreKeyHash);
+            return {
+                version: KeyExchange.version,
+                identityKey: this.identityKey.toString(),
+                signedPreKey: (0, utils_1.decodeBase64)(signedPreKey.publicKey),
+                signature: (0, utils_1.decodeBase64)(crypto_1.default.EdDSA.sign(signedPreKeyHash, this.privateIdentityKey.signatureKey)),
+                onetimePreKey: (0, utils_1.decodeBase64)(onetimePreKey.publicKey)
+            };
+        });
     }
     digestData(message) {
-        const ephemeralKey = crypto_1.default.ECDH.keyPair();
-        const signedPreKey = (0, utils_1.encodeBase64)(message.signedPreKey);
-        if (!crypto_1.default.EdDSA.verify(crypto_1.default.hash(signedPreKey), (0, utils_1.encodeBase64)(message.signature), (0, utils_1.encodeBase64)(message.publicKey)))
-            throw new Error("Signature verification failed");
-        const identityKey = (0, utils_1.encodeBase64)(message.identityKey);
-        const onetimePreKey = message.onetimePreKey ? (0, utils_1.encodeBase64)(message.onetimePreKey) : undefined;
-        const signedPreKeyHash = crypto_1.default.hash(signedPreKey);
-        const onetimePreKeyHash = onetimePreKey ? crypto_1.default.hash(onetimePreKey) : new Uint8Array();
-        const rootKey = crypto_1.default.hkdf(new Uint8Array([
-            ...crypto_1.default.ECDH.scalarMult(this._identityKey.secretKey, signedPreKey),
-            ...crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, identityKey),
-            ...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.rootKeyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.rootKeyLength);
-        const session = new double_ratchet_1.KeySession({ remoteKey: identityKey, rootKey });
-        const cyphertext = session.encrypt((0, utils_1.concatArrays)(crypto_1.default.hash(this._identityKey.publicKey), crypto_1.default.hash(identityKey)));
-        if (!cyphertext)
-            throw new Error("Decryption error");
-        return {
-            session,
-            message: {
-                version: KeyExchange.version,
-                publicKey: (0, utils_1.decodeBase64)(this._signatureKey.publicKey),
-                identityKey: (0, utils_1.decodeBase64)(this._identityKey.publicKey),
-                ephemeralKey: (0, utils_1.decodeBase64)(ephemeralKey.publicKey),
-                signedPreKeyHash: (0, utils_1.decodeBase64)(signedPreKeyHash),
-                onetimePreKeyHash: (0, utils_1.decodeBase64)(onetimePreKeyHash),
-                associatedData: (0, utils_1.decodeBase64)(cyphertext.encode())
-            },
-            identityKeys: {
-                publicKey: message.publicKey,
-                identityKey: message.identityKey
-            },
-        };
+        return __awaiter(this, void 0, void 0, function* () {
+            const ephemeralKey = crypto_1.default.ECDH.keyPair();
+            const signedPreKey = (0, utils_1.encodeBase64)(message.signedPreKey);
+            const identityKey = types_1.IdentityKey.from(message.identityKey);
+            if (!crypto_1.default.EdDSA.verify(crypto_1.default.hash(signedPreKey), (0, utils_1.encodeBase64)(message.signature), identityKey.signatureKey))
+                throw new Error("Signature verification failed");
+            const onetimePreKey = message.onetimePreKey ? (0, utils_1.encodeBase64)(message.onetimePreKey) : undefined;
+            const signedPreKeyHash = crypto_1.default.hash(signedPreKey);
+            const onetimePreKeyHash = onetimePreKey ? crypto_1.default.hash(onetimePreKey) : new Uint8Array();
+            const rootKey = crypto_1.default.hkdf(new Uint8Array([
+                ...crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, signedPreKey),
+                ...crypto_1.default.ECDH.scalarMult(ephemeralKey.secretKey, identityKey.exchangeKey),
+                ...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.rootKeyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.rootKeyLength);
+            const session = new double_ratchet_1.KeySession(this.sessions, { remoteKey: identityKey.exchangeKey, rootKey });
+            const cyphertext = yield session.encrypt((0, utils_1.concatArrays)(crypto_1.default.hash(this.identityKey.exchangeKey), crypto_1.default.hash(identityKey.exchangeKey)));
+            if (!cyphertext)
+                throw new Error("Decryption error");
+            return {
+                session,
+                message: {
+                    version: KeyExchange.version,
+                    identityKey: this.identityKey.toString(),
+                    ephemeralKey: (0, utils_1.decodeBase64)(ephemeralKey.publicKey),
+                    signedPreKeyHash: (0, utils_1.decodeBase64)(signedPreKeyHash),
+                    onetimePreKeyHash: (0, utils_1.decodeBase64)(onetimePreKeyHash),
+                    associatedData: (0, utils_1.decodeBase64)(cyphertext.toBytes())
+                },
+                identityKey
+            };
+        });
     }
     digestMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
-            const signedPreKey = yield this.bundleStore.get(message.signedPreKeyHash);
+            const signedPreKey = yield this.storage.get(message.signedPreKeyHash);
             const hash = message.signedPreKeyHash.concat(message.onetimePreKeyHash);
-            const onetimePreKey = yield this.bundleStore.get(hash);
+            const onetimePreKey = yield this.storage.get(hash);
+            const identityKey = types_1.IdentityKey.from(message.identityKey);
             if (!signedPreKey || !onetimePreKey || !message.identityKey || !message.ephemeralKey)
                 throw new Error("ACK message malformed");
-            if (!this.bundleStore.delete(hash))
+            if (!this.storage.delete(hash))
                 throw new Error("Bundle store deleting error");
-            const identityKey = (0, utils_1.encodeBase64)(message.identityKey);
             const ephemeralKey = (0, utils_1.encodeBase64)(message.ephemeralKey);
             const rootKey = crypto_1.default.hkdf(new Uint8Array([
-                ...crypto_1.default.ECDH.scalarMult(signedPreKey.secretKey, identityKey),
-                ...crypto_1.default.ECDH.scalarMult(this._identityKey.secretKey, ephemeralKey),
+                ...crypto_1.default.ECDH.scalarMult(signedPreKey.secretKey, identityKey.exchangeKey),
+                ...crypto_1.default.ECDH.scalarMult(this.privateIdentityKey.exchangeKey, ephemeralKey),
                 ...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.rootKeyLength).fill(0), KeyExchange.hkdfInfo, double_ratchet_1.KeySession.rootKeyLength);
-            const session = new double_ratchet_1.KeySession({ secretKey: this._identityKey.secretKey, rootKey });
-            const cleartext = session.decrypt((0, utils_1.encodeBase64)(message.associatedData));
+            const session = new double_ratchet_1.KeySession(this.sessions, { secretKey: this.privateIdentityKey.exchangeKey, rootKey });
+            const cleartext = yield session.decrypt((0, utils_1.encodeBase64)(message.associatedData));
             if (!cleartext)
                 throw new Error("Error decrypting ACK message");
-            if (!(0, utils_1.verifyArrays)(cleartext, (0, utils_1.concatArrays)(crypto_1.default.hash(identityKey), crypto_1.default.hash(this._identityKey.publicKey))))
+            if (!(0, utils_1.verifyArrays)(cleartext, (0, utils_1.concatArrays)(crypto_1.default.hash(identityKey.exchangeKey), crypto_1.default.hash(this.identityKey.exchangeKey))))
                 throw new Error("Error verifing Associated Data");
             return {
                 session,
-                identityKeys: {
-                    publicKey: message.publicKey,
-                    identityKey: message.identityKey
-                }
+                identityKey
             };
         });
     }
-    toJSON() {
-        return {
-            identityKey: this._identityKey,
-            signatureKey: this._signatureKey,
-            bundleStore: Array.from(this.bundleStore.entries())
-        };
-    }
-    static from(data) {
-        return new KeyExchange(data.signatureKey.secretKey, data.identityKey.secretKey, new AsyncMap(data.bundleStore));
-    }
 }
 exports.KeyExchange = KeyExchange;
 KeyExchange.version = 1;
 KeyExchange.hkdfInfo = (0, utils_1.encodeUTF8)("freesignal/x3dh/" + KeyExchange.version);
 KeyExchange.maxOPK = 10;
-class AsyncMap {
-    constructor(iterable) {
-        this.map = new Map(iterable);
-    }
-    set(key, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.map.set(key, value);
-            return;
-        });
-    }
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.get(key);
-        });
-    }
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.has(key);
-        });
-    }
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.map.delete(key);
-        });
-    }
-    entries() {
-        return this.map.entries();
-    }
-}

package/api.d.ts

@@ -1,54 +0,0 @@
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-import { Crypto, KeyExchangeData, KeyExchangeDataBundle, KeyExchangeSynMessage, LocalStorage } from "@freesignal/interfaces";
-import { ExportedKeySession } from "./double-ratchet";
-import { KeyExchange } from "./x3dh";
-import { Datagram, IdentityKeys, EncryptedData, UserId } from "./types";
-type DatagramId = string;
-export declare class FreeSignalAPI {
-    protected readonly signKey: Crypto.KeyPair;
-    protected readonly boxKey: Crypto.KeyPair;
-    protected readonly sessions: LocalStorage<UserId, ExportedKeySession>;
-    protected readonly keyExchange: KeyExchange;
-    protected readonly users: LocalStorage<UserId, IdentityKeys>;
-    readonly userId: UserId;
-    constructor(opts: {
-        secretSignKey: Uint8Array;
-        secretBoxKey: Uint8Array;
-        sessions: LocalStorage<UserId, ExportedKeySession>;
-        keyExchange: LocalStorage<string, Crypto.KeyPair>;
-        users: LocalStorage<UserId, IdentityKeys>;
-    });
-    get identityKeys(): IdentityKeys;
-    encryptData(data: Uint8Array, userId: string): Promise<EncryptedData>;
-    decryptData(data: Uint8Array, userId: string): Promise<Uint8Array>;
-    getHandshake(url: string, userId?: UserId): Promise<KeyExchangeData>;
-    postHandshake(url: string, message: KeyExchangeSynMessage): Promise<boolean>;
-    putHandshake(url: string, publicKey: string | Uint8Array, bundle: KeyExchangeDataBundle): Promise<boolean>;
-    deleteHandshake(url: string, publicKey: string | Uint8Array): Promise<boolean>;
-    getDatagrams(publicKey: string | Uint8Array, url: string): Promise<Datagram[]>;
-    postDatagrams(datagrams: Datagram[], publicKey: string | Uint8Array, url: string): Promise<number>;
-    deleteDatagrams(datagramIds: DatagramId[], publicKey: string | Uint8Array, url: string): Promise<number>;
-    createToken(publicKey: Uint8Array): string;
-    protected digestToken(auth?: string): Promise<{
-        identityKeys: IdentityKeys;
-        userId: UserId;
-    }>;
-}
-export {};

package/api.js

@@ -1,195 +0,0 @@
-"use strict";
-/**
- * FreeSignal Protocol
- *
- * Copyright (C) 2025  Christian Braghette
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreeSignalAPI = void 0;
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
-const double_ratchet_1 = require("./double-ratchet");
-const x3dh_1 = require("./x3dh");
-const utils_1 = require("@freesignal/utils");
-const types_1 = require("./types");
-class FreeSignalAPI {
-    constructor(opts) {
-        const { secretSignKey, secretBoxKey, sessions, keyExchange, users } = opts;
-        this.signKey = crypto_1.default.EdDSA.keyPair(secretSignKey);
-        this.boxKey = crypto_1.default.ECDH.keyPair(secretBoxKey);
-        this.sessions = sessions;
-        this.keyExchange = new x3dh_1.KeyExchange(secretSignKey, secretBoxKey, keyExchange);
-        this.users = users;
-        this.userId = types_1.UserId.getUserId(this.signKey.publicKey).toString();
-    }
-    get identityKeys() {
-        return {
-            publicKey: (0, utils_1.decodeBase64)(this.signKey.publicKey),
-            identityKey: (0, utils_1.decodeBase64)(this.boxKey.publicKey)
-        };
-    }
-    encryptData(data, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sessionJson = yield this.sessions.get(userId);
-            if (!sessionJson)
-                throw new Error('Session not found for user: ' + userId);
-            const session = double_ratchet_1.KeySession.from(sessionJson);
-            const encrypted = session.encrypt(data);
-            this.sessions.set(userId, session.toJSON()); // Ensure session is updated
-            return encrypted;
-        });
-    }
-    decryptData(data, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sessionJson = yield this.sessions.get(userId);
-            if (!sessionJson)
-                throw new Error('Session not found for user: ' + userId);
-            const session = double_ratchet_1.KeySession.from(sessionJson);
-            const decrypted = session.decrypt(data);
-            if (!decrypted)
-                throw new Error('Decryption failed for user: ' + userId);
-            this.sessions.set(userId, session.toJSON()); // Ensure session is updated
-            return decrypted;
-        });
-    }
-    getHandshake(url, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(`${url}/${userId !== null && userId !== void 0 ? userId : ''}`, {
-                method: 'GET'
-            });
-            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
-            if (body.type === 'error')
-                throw new Error(body.data);
-            return body.data;
-        });
-    }
-    postHandshake(url, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': types_1.XFreeSignal.MIME
-                },
-                body: types_1.XFreeSignal.encodeBody('data', message)
-            });
-            return res.status === 200;
-        });
-    }
-    putHandshake(url, publicKey, bundle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(url, {
-                method: 'PUT',
-                headers: {
-                    'Content-Type': types_1.XFreeSignal.MIME,
-                    authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
-                },
-                body: types_1.XFreeSignal.encodeBody('data', bundle)
-            });
-            return res.status === 201;
-        });
-    }
-    deleteHandshake(url, publicKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(url, {
-                method: 'DELETE',
-                headers: {
-                    authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
-                }
-            });
-            return res.status === 200;
-        });
-    }
-    getDatagrams(publicKey, url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield fetch(url, {
-                method: 'GET',
-                headers: {
-                    authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
-                }
-            });
-            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
-            if (body.type === 'error')
-                throw new Error(body.data);
-            return types_1.DataEncoder.from(yield this.decryptData(body.data, types_1.UserId.getUserId(publicKey).toString())).data.map(array => types_1.Datagram.from(array));
-        });
-    }
-    postDatagrams(datagrams, publicKey, url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.encryptData(new types_1.DataEncoder(datagrams.map(datagram => types_1.Datagram.from(datagram).encode())).encode(), types_1.UserId.getUserId(publicKey).toString());
-            const res = yield fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': types_1.XFreeSignal.MIME,
-                    authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
-                },
-                body: types_1.XFreeSignal.encodeBody('data', data.encode())
-            });
-            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
-            if (body.type === 'error')
-                throw new Error(body.data);
-            return types_1.DataEncoder.from(yield this.decryptData(body.data, types_1.UserId.getUserId(publicKey).toString())).data;
-        });
-    }
-    deleteDatagrams(datagramIds, publicKey, url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.encryptData(new types_1.DataEncoder(datagramIds.map(datagramId => crypto_1.default.UUID.parse(datagramId))).encode(), types_1.UserId.getUserId(publicKey).toString());
-            const res = yield fetch(url, {
-                method: 'DELETE',
-                headers: {
-                    'Content-Type': types_1.XFreeSignal.MIME,
-                    authorization: this.createToken(publicKey instanceof Uint8Array ? publicKey : (0, utils_1.encodeBase64)(publicKey))
-                },
-                body: types_1.XFreeSignal.encodeBody('data', data.encode())
-            });
-            const body = types_1.XFreeSignal.decodeBody(new Uint8Array(yield res.arrayBuffer()));
-            if (body.type === 'error')
-                throw new Error(body.data);
-            return types_1.DataEncoder.from(yield this.decryptData(body.data, types_1.UserId.getUserId(publicKey).toString())).data;
-        });
-    }
-    createToken(publicKey) {
-        const signature = crypto_1.default.EdDSA.sign(crypto_1.default.hash(crypto_1.default.ECDH.scalarMult(publicKey, this.boxKey.secretKey)), this.signKey.secretKey);
-        return `Bearer ${this.userId}:${(0, utils_1.decodeBase64)(signature)}`;
-    }
-    ;
-    digestToken(auth) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (auth && auth.startsWith("Bearer ")) {
-                const [userId, signature] = auth.substring(7).split(":");
-                const identityKeys = yield this.users.get(userId);
-                if (!identityKeys)
-                    throw new Error('User not found or invalid auth token');
-                if (crypto_1.default.EdDSA.verify(crypto_1.default.hash(crypto_1.default.ECDH.scalarMult((0, utils_1.encodeBase64)(identityKeys.identityKey), this.boxKey.secretKey)), (0, utils_1.encodeBase64)(signature), (0, utils_1.encodeBase64)(identityKeys.publicKey)))
-                    return { identityKeys, userId: auth };
-                else
-                    throw new Error('Authorization token not valid');
-            }
-            throw new Error('Authorization header is required');
-        });
-    }
-}
-exports.FreeSignalAPI = FreeSignalAPI;