@freesignal/protocol 0.4.3 → 0.4.4

package/dist/double-ratchet.d.ts

@@ -45,14 +45,21 @@ export declare class KeySession {
     private rootKey?;
     private sendingChain?;
     private receivingChain?;
+    private nextHeaderKey?;
     private previousKeys;
     constructor(opts?: {
         id?: string;
         secretKey?: Uint8Array;
         remoteKey?: Uint8Array;
+        headerKey?: Uint8Array;
+        nextHeaderKey?: Uint8Array;
         rootKey?: Uint8Array;
     });
     private getChain;
+    getHeaderKeys(): {
+        readonly sending?: Uint8Array;
+        readonly receiving?: Uint8Array;
+    };
     getSendingKey(): PrivateEncryptionKeys | undefined;
     getReceivingKey(encryptionKeys: EncryptionKeys): Uint8Array | undefined;
     /**
@@ -79,6 +86,8 @@ interface ExportedKeyChain {
     publicKey: string;
     remoteKey: string;
     chainKey: string;
+    nextHeaderKey: string;
+    headerKey?: string;
     count: number;
     previousCount: number;
 }

package/dist/double-ratchet.js

@@ -36,17 +36,26 @@ class KeySession {
         this.keyPair = crypto_1.default.ECDH.keyPair(opts.secretKey);
         if (opts.rootKey)
             this.rootKey = opts.rootKey;
+        if (opts.nextHeaderKey)
+            this.nextHeaderKey = opts.nextHeaderKey;
         if (opts.remoteKey) {
-            this.sendingChain = this.getChain(opts.remoteKey);
+            this.sendingChain = this.getChain(opts.remoteKey, opts.headerKey);
         }
     }
-    getChain(remoteKey, previousCount) {
+    getChain(remoteKey, headerKey, previousCount) {
         const sharedKey = crypto_1.default.ECDH.scalarMult(this.keyPair.secretKey, remoteKey);
         if (!this.rootKey)
             this.rootKey = crypto_1.default.hash(sharedKey);
-        const hashkey = crypto_1.default.hkdf(sharedKey, this.rootKey, KeySession.info, KeySession.keyLength * 2);
+        const hashkey = crypto_1.default.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), previousCount);
+        return new KeyChain(this.publicKey, remoteKey, hashkey.subarray(KeySession.keyLength, KeySession.keyLength * 2), hashkey.subarray(KeySession.keyLength * 2), headerKey, previousCount);
+    }
+    getHeaderKeys() {
+        var _a, _b, _c;
+        return {
+            sending: (_a = this.sendingChain) === null || _a === void 0 ? void 0 : _a.headerKey,
+            receiving: (_b = this.nextHeaderKey) !== null && _b !== void 0 ? _b : (_c = this.receivingChain) === null || _c === void 0 ? void 0 : _c.headerKey
+        };
     }
     getSendingKey() {
         if (!this.sendingChain)
@@ -61,16 +70,17 @@ class KeySession {
         };
     }
     getReceivingKey(encryptionKeys) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         if (!this.previousKeys.has((0, utils_1.decodeBase64)(encryptionKeys.publicKey) + encryptionKeys.count.toString())) {
             if (!(0, utils_1.compareBytes)(encryptionKeys.publicKey, (_b = (_a = this.receivingChain) === null || _a === void 0 ? void 0 : _a.remoteKey) !== null && _b !== void 0 ? _b : new Uint8Array())) {
                 while (this.receivingChain && this.receivingChain.count < encryptionKeys.previous) {
                     const key = this.receivingChain.getKey();
                     this.previousKeys.set((0, utils_1.decodeBase64)(this.receivingChain.remoteKey) + this.receivingChain.count.toString(), key);
                 }
-                this.receivingChain = this.getChain(encryptionKeys.publicKey);
+                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);
+                this.nextHeaderKey = undefined;
                 this.keyPair = crypto_1.default.ECDH.keyPair();
-                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_c = this.sendingChain) === null || _c === void 0 ? void 0 : _c.count);
+                this.sendingChain = this.getChain(encryptionKeys.publicKey, (_e = this.sendingChain) === null || _e === void 0 ? void 0 : _e.nextHeaderKey, (_f = this.sendingChain) === null || _f === void 0 ? void 0 : _f.count);
             }
             if (!this.receivingChain)
                 throw new Error("Error initializing receivingChain");
@@ -122,10 +132,12 @@ KeySession.version = 1;
 KeySession.info = "/freesignal/double-ratchet/v0." + KeySession.version;
 KeySession.maxCount = 65536;
 class KeyChain {
-    constructor(publicKey, remoteKey, chainKey, previousCount = 0) {
+    constructor(publicKey, remoteKey, chainKey, nextHeaderKey, headerKey, previousCount = 0) {
         this.publicKey = publicKey;
         this.remoteKey = remoteKey;
         this.chainKey = chainKey;
+        this.nextHeaderKey = nextHeaderKey;
+        this.headerKey = headerKey;
         this.previousCount = previousCount;
         this._count = 0;
     }
@@ -147,12 +159,14 @@ class KeyChain {
             publicKey: (0, utils_1.decodeBase64)(this.publicKey),
             remoteKey: (0, utils_1.decodeBase64)(this.remoteKey),
             chainKey: (0, utils_1.decodeBase64)(this.chainKey),
+            nextHeaderKey: (0, utils_1.decodeBase64)(this.nextHeaderKey),
+            headerKey: this.headerKey ? (0, utils_1.decodeBase64)(this.headerKey) : undefined,
             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), obj.previousCount);
+        const chain = new KeyChain((0, utils_1.encodeBase64)(obj.publicKey), (0, utils_1.encodeBase64)(obj.remoteKey), (0, utils_1.encodeBase64)(obj.chainKey), (0, utils_1.encodeBase64)(obj.nextHeaderKey), obj.headerKey ? (0, utils_1.encodeBase64)(obj.headerKey) : undefined, obj.previousCount);
         chain._count = obj.count;
         return chain;
     }

package/dist/index.d.ts

@@ -19,7 +19,7 @@
 import { LocalStorage, Crypto, Database, KeyExchangeDataBundle } from "@freesignal/interfaces";
 import { ExportedKeySession } from "./double-ratchet";
 import { IdentityKey, PrivateIdentityKey } from "./types";
-import { FreeSignalNode } from "./node";
+import { BootstrapRequest, FreeSignalNode } from "./node";
 /**
  * Creates a new Double Ratchet session for secure message exchange.
  *
@@ -48,5 +48,6 @@ export declare function createNode(storage: Database<{
     keyExchange: LocalStorage<string, Crypto.KeyPair>;
     users: LocalStorage<string, IdentityKey>;
     bundles: LocalStorage<string, KeyExchangeDataBundle>;
+    bootstraps: LocalStorage<string, BootstrapRequest>;
 }>, privateIdentityKey?: PrivateIdentityKey): FreeSignalNode;
 export * from "./types";

package/dist/node.d.ts

@@ -17,20 +17,19 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>
  */
 import { Database, LocalStorage, Crypto, KeyExchangeDataBundle, KeyExchangeData } from "@freesignal/interfaces";
-import { Datagram, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
+import { Datagram, DatagramHeader, IdentityKey, PrivateIdentityKey, Protocols, UserId } from "./types";
 import { KeyExchange } from "./x3dh";
 import { ExportedKeySession, KeySession } from "./double-ratchet";
-declare class BootstrapRequest {
+export declare class BootstrapRequest {
     #private;
     readonly senderId: UserId | string;
-    readonly data: KeyExchangeData;
-    private readonly acceptFn;
-    constructor(senderId: UserId | string, data: KeyExchangeData, acceptFn: (data: KeyExchangeData) => Promise<Datagram>);
+    private readonly data;
+    constructor(senderId: UserId | string, data: KeyExchangeData);
     get status(): "pending" | "accepted" | "denied";
-    accept(): Promise<Datagram | undefined>;
+    get(): Promise<KeyExchangeData | undefined>;
+    accept(): Promise<KeyExchangeData | undefined>;
     deny(): void;
 }
-type OpenFnReturns = Uint8Array | UserId | Datagram | UserId | KeyExchangeData | undefined | void;
 export declare class FreeSignalNode {
     protected readonly privateIdentityKey: PrivateIdentityKey;
     protected readonly sessions: SessionMap;
@@ -38,16 +37,18 @@ export declare class FreeSignalNode {
     protected readonly bundles: LocalStorage<string, KeyExchangeDataBundle>;
     protected readonly keyExchange: KeyExchange;
     protected readonly discovers: Set<string>;
-    protected readonly bootstraps: Set<BootstrapRequest>;
+    protected readonly bootstraps: LocalStorage<string, BootstrapRequest>;
     constructor(storage: Database<{
         sessions: LocalStorage<string, ExportedKeySession>;
         keyExchange: LocalStorage<string, Crypto.KeyPair>;
         users: LocalStorage<string, IdentityKey>;
         bundles: LocalStorage<string, KeyExchangeDataBundle>;
+        bootstraps: LocalStorage<string, BootstrapRequest>;
     }>, privateIdentityKey?: PrivateIdentityKey);
     get identityKey(): IdentityKey;
     get userId(): UserId;
-    get requests(): BootstrapRequest[];
+    onRequest: (request: BootstrapRequest) => void;
+    getRequest(userId: string): Promise<KeyExchangeData | undefined>;
     protected encrypt(receiverId: string | UserId, protocol: Protocols, data: Uint8Array): Promise<Datagram>;
     packHandshake(data: KeyExchangeData): Promise<Datagram>;
     packData<T>(receiverId: string | UserId, data: T): Promise<Datagram>;
@@ -55,7 +56,16 @@ export declare class FreeSignalNode {
     packDiscover(receiverId: string | UserId, discoverId: string | UserId): Promise<Datagram>;
     packBootstrap(receiverId: string | UserId): Promise<Datagram>;
     protected decrypt(datagram: Datagram): Promise<Uint8Array>;
-    open<T extends OpenFnReturns>(datagram: Datagram | Uint8Array): Promise<T>;
+    /**
+     * Open the datagram and execute operation of Discover and Handshake.
+     *
+     * @param datagram
+     * @returns Header and decrypted payload
+     */
+    open(datagram: Datagram | Uint8Array): Promise<{
+        header: DatagramHeader;
+        payload?: Uint8Array;
+    }>;
 }
 declare class SessionMap implements LocalStorage<string, KeySession> {
     readonly storage: LocalStorage<string, ExportedKeySession>;

package/dist/node.js

@@ -39,28 +39,31 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 };
 var _BootstrapRequest_status;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FreeSignalNode = void 0;
+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");
 class BootstrapRequest {
-    constructor(senderId, data, acceptFn) {
+    constructor(senderId, data) {
         this.senderId = senderId;
         this.data = data;
-        this.acceptFn = acceptFn;
         _BootstrapRequest_status.set(this, 'pending');
     }
     get status() {
         return __classPrivateFieldGet(this, _BootstrapRequest_status, "f");
     }
+    get() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted' ? this.data : undefined;
+        });
+    }
     accept() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.status === 'pending')
                 __classPrivateFieldSet(this, _BootstrapRequest_status, 'accepted', "f");
-            if (__classPrivateFieldGet(this, _BootstrapRequest_status, "f") === 'accepted')
-                return yield this.acceptFn(this.data);
+            return yield this.get();
         });
     }
     deny() {
@@ -69,16 +72,18 @@ class BootstrapRequest {
         return;
     }
 }
+exports.BootstrapRequest = BootstrapRequest;
 _BootstrapRequest_status = new WeakMap();
 class FreeSignalNode {
     constructor(storage, privateIdentityKey) {
         this.discovers = new Set();
-        this.bootstraps = new Set();
+        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.users = storage.users;
         this.bundles = storage.bundles;
+        this.bootstraps = storage.bootstraps;
     }
     get identityKey() {
         return this.privateIdentityKey.identityKey;
@@ -86,8 +91,11 @@ class FreeSignalNode {
     get userId() {
         return types_1.UserId.fromKey(this.identityKey);
     }
-    get requests() {
-        return Array.from(this.bootstraps.values());
+    getRequest(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = (yield this.bootstraps.get(userId))) === null || _a === void 0 ? void 0 : _a.get();
+        });
     }
     encrypt(receiverId, protocol, data) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -152,10 +160,19 @@ class FreeSignalNode {
             return decrypted;
         });
     }
+    /**
+     * Open the datagram and execute operation of Discover and Handshake.
+     *
+     * @param datagram
+     * @returns Header and decrypted payload
+     */
     open(datagram) {
         return __awaiter(this, void 0, void 0, function* () {
             if (datagram instanceof Uint8Array)
                 datagram = types_1.Datagram.from(datagram);
+            let out = {
+                header: types_1.DatagramHeader.from(datagram.header)
+            };
             switch (datagram.protocol) {
                 case types_1.Protocols.HANDSHAKE:
                     if (!datagram.payload)
@@ -168,11 +185,13 @@ class FreeSignalNode {
                     yield this.users.set(userId.toString(), identityKey);
                     yield this.sessions.set(userId.toString(), session);
                     yield this.bundles.set(userId.toString(), (0, utils_1.decodeData)(associatedData));
-                    return;
+                    return out;
                 case types_1.Protocols.MESSAGE:
-                    return (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                    out.payload = (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                    return out;
                 case types_1.Protocols.RELAY:
-                    return (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                    out.payload = (0, utils_1.decodeData)(yield this.decrypt(datagram));
+                    return out;
                 case types_1.Protocols.DISCOVER:
                     const message = (0, utils_1.decodeData)(yield this.decrypt(datagram));
                     if (message.type === types_1.DiscoverType.REQUEST && message.discoverId && !(yield this.users.has(message.discoverId))) {
@@ -183,12 +202,12 @@ class FreeSignalNode {
                         else {
                             const bundle = yield this.bundles.get(message.discoverId);
                             if (!bundle)
-                                return;
+                                return out;
                             const { version, identityKey, signedPreKey, signature } = bundle;
                             const onetimePreKey = bundle.onetimePreKeys.shift();
                             if (!onetimePreKey) {
                                 yield this.bundles.delete(message.discoverId);
-                                return;
+                                return out;
                             }
                             data = {
                                 version,
@@ -199,22 +218,31 @@ class FreeSignalNode {
                             };
                         }
                         const response = { type: types_1.DiscoverType.RESPONSE, discoverId: message.discoverId, data };
-                        return yield this.encrypt(datagram.sender, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response));
+                        out.payload = (yield this.encrypt(datagram.sender, types_1.Protocols.DISCOVER, (0, utils_1.encodeData)(response))).toBytes();
                     }
                     else if (message.type === types_1.DiscoverType.RESPONSE && this.discovers.has(message.discoverId)) {
                         this.discovers.delete(message.discoverId);
-                        return message.data;
+                        if (message.data)
+                            out.payload = (0, utils_1.encodeData)(message.data);
                     }
-                    return;
+                    return out;
                 case types_1.Protocols.BOOTSTRAP:
                     if (datagram.payload) {
                         const data = (0, utils_1.decodeData)(datagram.payload);
                         if (!(0, utils_1.compareBytes)(types_1.UserId.fromKey(data.identityKey).toBytes(), (0, utils_1.encodeBase64)(datagram.sender)))
-                            return;
-                        this.bootstraps.add(new BootstrapRequest(datagram.sender, data, (data) => this.packHandshake(data)));
+                            new Error("Malicious bootstrap request");
+                        const request = new BootstrapRequest(datagram.sender, data);
+                        yield this.bootstraps.set(datagram.sender, request);
+                        this.onRequest(request);
                     }
                     ;
-                    return;
+                    const request = yield this.bootstraps.get(datagram.sender);
+                    if (request) {
+                        const data = yield request.get();
+                        if (data)
+                            out.payload = (0, utils_1.encodeData)(data);
+                    }
+                    return out;
                 default:
                     throw new Error("Invalid protocol");
             }

package/dist/test.js

@@ -8,34 +8,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
-const utils_1 = require("@freesignal/utils");
 const _1 = require(".");
-const crypto_1 = __importDefault(require("@freesignal/crypto"));
 console.log("FreeSignal protocol test");
-const bob = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap() });
-const alice = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap() });
+const bob = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap(), bootstraps: new _1.AsyncMap() });
+const alice = (0, _1.createNode)({ keyExchange: new _1.AsyncMap(), sessions: new _1.AsyncMap(), users: new _1.AsyncMap(), bundles: new _1.AsyncMap(), bootstraps: new _1.AsyncMap() });
 setImmediate(() => __awaiter(void 0, void 0, void 0, function* () {
     const bobBootstrap = yield bob.packBootstrap(alice.userId);
+    alice.onRequest = (request) => { request.accept(); };
     yield alice.open(bobBootstrap);
-    const bootstraps = yield Promise.all(alice.requests.map(request => request.accept()));
-    const aliceHandshake = bootstraps.filter(value => (value === null || value === void 0 ? void 0 : value.receiver) === bob.userId.toString())[0];
-    if (!aliceHandshake)
+    const bobRequest = yield alice.getRequest(bob.userId.toString());
+    if (!bobRequest)
         throw new Error("Bootstrap Failed");
+    const aliceHandshake = yield alice.packHandshake(bobRequest);
     yield bob.open(aliceHandshake);
     const first = (yield bob.packData(alice.userId, "Hi Alice!")).toBytes();
-    console.log("Bob: ", yield alice.open(first));
+    console.log("Bob: ", (yield alice.open(first)).payload);
     const second = yield alice.packData(bob.userId, "Hi Bob!");
-    console.log("Alice: ", yield bob.open(second));
+    console.log("Alice: ", (yield bob.open(second)).payload);
     const third = yield Promise.all(["How are you?", "How are this days?", "For me it's a good time"].map(msg => bob.packData(alice.userId, msg)));
     third.forEach((data) => __awaiter(void 0, void 0, void 0, function* () {
-        console.log("Bob: ", yield alice.open(data));
+        console.log("Bob: ", (yield alice.open(data)).payload);
     }));
     const fourth = yield alice.packData(bob.userId, "Not so bad my man");
-    console.log("Alice: ", yield bob.open(fourth));
-    const testone = yield Promise.all(Array(400).fill(0).map(() => alice.packData(bob.userId, (0, utils_1.decodeBase64)(crypto_1.default.randomBytes(64)))));
-    console.log((yield bob.open(testone[350])));
+    console.log("Alice: ", (yield bob.open(fourth)).payload);
+    //const testone = await Promise.all(Array(400).fill(0).map(() => alice.packData(bob.userId, decodeBase64(crypto.randomBytes(64)))));
+    //console.log(((await bob.open(testone[350])).payload));
 }));

package/dist/types.d.ts

@@ -91,15 +91,19 @@ interface DatagramJSON {
 export interface SignedDatagram extends Datagram {
     signature: string;
 }
-export interface DatagramHeader {
+export declare class DatagramHeader implements Encodable {
+    private static offset;
     readonly id: string;
     readonly version: number;
     readonly sender: string;
     readonly receiver: string;
     readonly protocol: Protocols;
     readonly createdAt: number;
+    private constructor();
+    toBytes(): Uint8Array;
+    static from(data: Uint8Array | string): DatagramHeader;
 }
-export declare class Datagram implements Encodable {
+export declare class Datagram implements Encodable, DatagramHeader {
     static version: number;
     private _id;
     private _version;

package/dist/types.js

@@ -30,7 +30,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncMap = exports.EncryptedData = exports.Datagram = exports.Protocols = exports.DiscoverType = exports.PrivateIdentityKey = exports.IdentityKey = exports.UserId = void 0;
+exports.AsyncMap = exports.EncryptedData = exports.Datagram = exports.DatagramHeader = exports.Protocols = exports.DiscoverType = exports.PrivateIdentityKey = exports.IdentityKey = exports.UserId = void 0;
 exports.encryptData = encryptData;
 exports.decryptData = decryptData;
 const utils_1 = require("@freesignal/utils");
@@ -225,6 +225,26 @@ var Protocols;
     Protocols.decode = decode;
 })(Protocols || (exports.Protocols = Protocols = {}));
 ;
+class DatagramHeader {
+    constructor(data) {
+        this.version = data[0] & 127;
+        this.protocol = Protocols.decode(data.subarray(1, 2));
+        this.id = crypto_1.default.UUID.stringify(data.subarray(2, 18));
+        this.createdAt = (0, utils_1.bytesToNumber)(data.subarray(18, 26));
+        this.sender = (0, utils_1.decodeBase64)(data.subarray(26, 26 + crypto_1.default.EdDSA.publicKeyLength));
+        this.receiver = (0, utils_1.decodeBase64)(data.subarray(26 + crypto_1.default.EdDSA.publicKeyLength, DatagramHeader.offset));
+    }
+    toBytes() {
+        return (0, utils_1.concatBytes)((0, utils_1.numberToBytes)(this.version, 1), Protocols.encode(this.protocol, 1), crypto_1.default.UUID.parse(this.protocol), (0, utils_1.numberToBytes)(this.createdAt, 8), (0, utils_1.encodeBase64)(this.sender), (0, utils_1.encodeBase64)(this.receiver));
+    }
+    static from(data) {
+        if (typeof data === 'string')
+            data = (0, utils_1.encodeBase64)(data);
+        return new DatagramHeader(data);
+    }
+}
+exports.DatagramHeader = DatagramHeader;
+DatagramHeader.offset = 26 + crypto_1.default.EdDSA.publicKeyLength * 2;
 class Datagram {
     constructor(sender, receiver, protocol, payload) {
         this._id = crypto_1.default.UUID.generate().toString();

package/dist/x3dh.js

@@ -149,5 +149,5 @@ class KeyExchange {
 }
 exports.KeyExchange = KeyExchange;
 KeyExchange.version = 1;
-KeyExchange.hkdfInfo = "freesignal/x3dh/" + KeyExchange.version;
+KeyExchange.hkdfInfo = "freesignal/x3dh/v." + KeyExchange.version;
 KeyExchange.maxOPK = 10;

package/package.json

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