@unknownncat/swt-libsignal 1.0.6 → 1.1.0

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { SessionCipher } from '../session/cipher/session-cipher';
+export { SessionBuilder } from '../session/builder/session-builder';
+export { SessionRecord, SessionEntry } from '../session/record';

package/dist/core/index.js

@@ -0,0 +1,3 @@
+export { SessionCipher } from '../session/cipher/session-cipher';
+export { SessionBuilder } from '../session/builder/session-builder';
+export { SessionRecord, SessionEntry } from '../session/record';

package/dist/crypto.d.ts

@@ -1,2 +1,2 @@
-import type { CryptoAPI } from './types/crypto.js';
+import type { CryptoAPI } from './types/crypto';
 export declare const crypto: CryptoAPI;

package/dist/crypto.js

@@ -1,24 +1,27 @@
 import { createCipheriv, createDecipheriv, createHmac, createHash, randomBytes } from 'node:crypto';
 const EMPTY_BUFFER = Buffer.alloc(0);
-function toBuffer(data) {
+function toBufferView(data) {
     return Buffer.isBuffer(data)
         ? data
         : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
 }
+function toBufferCopy(data) {
+    return Buffer.from(data);
+}
 function toUint8(data) {
     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
 }
 function encrypt(key, plaintext, options) {
-    const k = toBuffer(key);
+    const k = toBufferCopy(key);
     if (k.length !== 32)
         throw new Error('Key must be 32 bytes');
-    const iv = options?.iv ? toBuffer(options.iv) : randomBytes(12);
+    const iv = options?.iv ? toBufferCopy(options.iv) : randomBytes(12);
     if (iv.length !== 12)
         throw new Error('IV must be 12 bytes for AES-GCM');
     const cipher = createCipheriv('aes-256-gcm', k, iv);
     if (options?.aad)
-        cipher.setAAD(toBuffer(options.aad));
-    const encrypted = Buffer.concat([cipher.update(toBuffer(plaintext)), cipher.final()]);
+        cipher.setAAD(toBufferView(options.aad));
+    const encrypted = Buffer.concat([cipher.update(toBufferView(plaintext)), cipher.final()]);
     const tag = cipher.getAuthTag();
     k.fill(0);
     return {
@@ -28,13 +31,13 @@ function encrypt(key, plaintext, options) {
     };
 }
 function decrypt(key, data, options) {
-    const k = toBuffer(key);
-    const decipher = createDecipheriv('aes-256-gcm', k, toBuffer(data.iv));
+    const k = toBufferCopy(key);
+    const decipher = createDecipheriv('aes-256-gcm', k, toBufferView(data.iv));
     if (options?.aad) {
-        decipher.setAAD(toBuffer(options.aad));
+        decipher.setAAD(toBufferView(options.aad));
     }
-    decipher.setAuthTag(toBuffer(data.tag));
-    const cipherBuf = toBuffer(data.ciphertext);
+    decipher.setAuthTag(toBufferView(data.tag));
+    const cipherBuf = toBufferView(data.ciphertext);
     const decrypted = decipher.update(cipherBuf);
     const final = decipher.final();
     const plaintext = decrypted.length === 0
@@ -69,9 +72,9 @@ function hkdf(ikm, salt, info, options) {
     }
     const hashLen = 32;
     const blocksNeeded = Math.ceil(length / hashLen);
-    const ikmBuf = toBuffer(ikm);
-    const saltBuf = toBuffer(salt);
-    const infoBuf = toBuffer(info);
+    const ikmBuf = toBufferCopy(ikm);
+    const saltBuf = toBufferCopy(salt);
+    const infoBuf = toBufferCopy(info);
     const prkKey = saltBuf.length ? saltBuf : Buffer.alloc(hashLen, 0);
     try {
         const prk = createHmac('sha256', prkKey)
@@ -112,12 +115,12 @@ function hkdf(ikm, salt, info, options) {
 }
 function sha512(data) {
     return toUint8(createHash('sha512')
-        .update(toBuffer(data))
+        .update(toBufferView(data))
         .digest());
 }
 function hmacSha256(key, data) {
-    return toUint8(createHmac('sha256', toBuffer(key))
-        .update(toBuffer(data))
+    return toUint8(createHmac('sha256', toBufferView(key))
+        .update(toBufferView(data))
         .digest());
 }
 export const crypto = {

package/dist/curve.d.ts

@@ -1,4 +1,4 @@
-import type { DHKeyPair, SignalAsymmetricAPI } from './types/asymmetric.js';
+import type { DHKeyPair, SignalAsymmetricAPI } from './types/asymmetric';
 declare function generateKeyPair(): Promise<DHKeyPair>;
 declare function calculateSignature(identityPrivateKey: Uint8Array, data: Uint8Array): Uint8Array<ArrayBufferLike>;
 export declare const signalCrypto: SignalAsymmetricAPI;

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { SignalError, UntrustedIdentityKeyError, SessionError, MessageCounterError, PreKeyError, } from '../signal-errors';
+export { ProtobufValidationError } from './protobuf-validation-error';

package/dist/errors/index.js

@@ -0,0 +1,2 @@
+export { SignalError, UntrustedIdentityKeyError, SessionError, MessageCounterError, PreKeyError, } from '../signal-errors';
+export { ProtobufValidationError } from './protobuf-validation-error';

package/dist/errors/protobuf-validation-error.d.ts

@@ -0,0 +1,4 @@
+export declare class ProtobufValidationError extends Error {
+    readonly name = "ProtobufValidationError";
+    constructor(message: string);
+}

package/dist/errors/protobuf-validation-error.js

@@ -0,0 +1,6 @@
+export class ProtobufValidationError extends Error {
+    name = 'ProtobufValidationError';
+    constructor(message) {
+        super(message);
+    }
+}

package/dist/fingerprint.js

@@ -1,4 +1,4 @@
-import { crypto } from './crypto.js';
+import { crypto } from './crypto';
 const VERSION = 0;
 function numberToUint16BE(num) {
     const out = new Uint8Array(2);

package/dist/index.d.ts

@@ -1,19 +1,21 @@
-export { ProtocolAddress } from './protocol_address.js';
-export { SessionRecord, SessionEntry } from './session/record/index.js';
-export type { ChainKey, ChainState, CurrentRatchet, IndexInfo } from './session/record/index.js';
-export { SessionCipher } from './session/cipher/index.js';
-export type { EncryptResult, DecryptResult, DecryptWithSessionResult, SessionCipherStorage } from './session/cipher/index.js';
-export { SessionBuilder } from './session/builder/session-builder.js';
-export type { PreKeyBundle, SessionBuilderStorage, KeyPair, IdentityKeyPair } from './session/builder/index.js';
-export { crypto } from './crypto.js';
-export { signalCrypto, generateKeyPair, calculateSignature } from './curve.js';
-export type { CryptoAPI } from './types/crypto.js';
-export type { SignalAsymmetricAPI, IdentityKeyPair as AsymIdentityKeyPair, DHKeyPair } from './types/asymmetric.js';
-export { generateIdentityKeyPair, generateRegistrationId, generateSignedPreKey, generatePreKey } from './key-helper.js';
-export type { SignedPreKey, PreKey } from './key-helper.js';
-export { FingerprintGenerator } from './fingerprint.js';
-export { SignalError, UntrustedIdentityKeyError, SessionError, MessageCounterError, PreKeyError } from './signal-errors.js';
-export * from "./ratchet-types.js";
-export type { BaseKeyType as BaseKeyTypeValue } from './ratchet-types.js';
-export { PreKeyWhisperMessage, WhisperMessage } from './protobuf.js';
-export { enqueue } from './job_queue.js';
+export { ProtocolAddress } from './protocol_address';
+export { SessionRecord, SessionEntry } from './session/record';
+export type { ChainKey, ChainState, CurrentRatchet, IndexInfo } from './session/record';
+export { SessionCipher } from './core';
+export { WhisperMessageEncoder } from './transport';
+export type { EncryptResult, DecryptResult, DecryptWithSessionResult, SessionCipherStorage, } from './types';
+export { SessionBuilder } from './session/builder/session-builder';
+export type { PreKeyBundle, SessionBuilderStorage, KeyPair, IdentityKeyPair, } from './session/builder';
+export { crypto } from './crypto';
+export { signalCrypto, generateKeyPair, calculateSignature } from './curve';
+export type { CryptoAPI } from './types/crypto';
+export type { SignalAsymmetricAPI, IdentityKeyPair as AsymIdentityKeyPair, DHKeyPair } from './types/asymmetric';
+export { generateIdentityKeyPair, generateRegistrationId, generateSignedPreKey, generatePreKey, } from './key-helper';
+export type { SignedPreKey, PreKey } from './key-helper';
+export { FingerprintGenerator } from './fingerprint';
+export { SignalError, UntrustedIdentityKeyError, SessionError, MessageCounterError, PreKeyError, ProtobufValidationError, } from './errors';
+export * from './ratchet-types';
+export type { BaseKeyType as BaseKeyTypeValue } from './ratchet-types';
+export { WhisperMessageCodec, PreKeyWhisperMessageCodec } from './protobuf';
+export type { WhisperMessage, PreKeyWhisperMessage } from './protobuf';
+export { enqueue } from './job_queue';

package/dist/index.js

@@ -1,12 +1,13 @@
-export { ProtocolAddress } from './protocol_address.js';
-export { SessionRecord, SessionEntry } from './session/record/index.js';
-export { SessionCipher } from './session/cipher/index.js';
-export { SessionBuilder } from './session/builder/session-builder.js';
-export { crypto } from './crypto.js';
-export { signalCrypto, generateKeyPair, calculateSignature } from './curve.js';
-export { generateIdentityKeyPair, generateRegistrationId, generateSignedPreKey, generatePreKey } from './key-helper.js';
-export { FingerprintGenerator } from './fingerprint.js';
-export { SignalError, UntrustedIdentityKeyError, SessionError, MessageCounterError, PreKeyError } from './signal-errors.js';
-export * from "./ratchet-types.js";
-export { PreKeyWhisperMessage, WhisperMessage } from './protobuf.js';
-export { enqueue } from './job_queue.js';
+export { ProtocolAddress } from './protocol_address';
+export { SessionRecord, SessionEntry } from './session/record';
+export { SessionCipher } from './core';
+export { WhisperMessageEncoder } from './transport';
+export { SessionBuilder } from './session/builder/session-builder';
+export { crypto } from './crypto';
+export { signalCrypto, generateKeyPair, calculateSignature } from './curve';
+export { generateIdentityKeyPair, generateRegistrationId, generateSignedPreKey, generatePreKey, } from './key-helper';
+export { FingerprintGenerator } from './fingerprint';
+export { SignalError, UntrustedIdentityKeyError, SessionError, MessageCounterError, PreKeyError, ProtobufValidationError, } from './errors';
+export * from './ratchet-types';
+export { WhisperMessageCodec, PreKeyWhisperMessageCodec } from './protobuf';
+export { enqueue } from './job_queue';

package/dist/job_queue.d.ts

@@ -1,3 +1,6 @@
 type Awaitable<T> = () => Promise<T>;
-export declare function enqueue<T>(bucket: unknown, awaitable: Awaitable<T>): Promise<T>;
+export interface EnqueueOptions {
+    timeoutMs?: number;
+}
+export declare function enqueue<T>(bucket: unknown, awaitable: Awaitable<T>, options?: EnqueueOptions): Promise<T>;
 export {};

package/dist/job_queue.js

@@ -1,5 +1,24 @@
 const queueBuckets = new Map();
 const GC_LIMIT = 10_000;
+async function runWithTimeout(job) {
+    if (job.timeoutMs === undefined) {
+        return job.awaitable();
+    }
+    let timeoutId;
+    try {
+        return await Promise.race([
+            job.awaitable(),
+            new Promise((_, reject) => {
+                timeoutId = setTimeout(() => reject(new Error(`queue job timeout after ${job.timeoutMs}ms`)), job.timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
 async function asyncQueueExecutor(bucket, state) {
     const queue = state.queue;
     try {
@@ -10,7 +29,7 @@ async function asyncQueueExecutor(bucket, state) {
                 if (!job)
                     continue;
                 try {
-                    const result = await job.awaitable();
+                    const result = await runWithTimeout(job);
                     job.resolve(result);
                 }
                 catch (err) {
@@ -29,20 +48,24 @@ async function asyncQueueExecutor(bucket, state) {
         queueBuckets.delete(bucket);
     }
 }
-export function enqueue(bucket, awaitable) {
+export function enqueue(bucket, awaitable, options) {
     let state = queueBuckets.get(bucket);
     const isInactive = !state;
     if (!state) {
-        state = {
-            queue: [],
-            offset: 0,
-            running: false
-        };
+        state = { queue: [], offset: 0, running: false };
         queueBuckets.set(bucket, state);
     }
-    const queue = state.queue;
+    const timeoutMs = options?.timeoutMs;
+    if (timeoutMs !== undefined && (!Number.isInteger(timeoutMs) || timeoutMs <= 0)) {
+        throw new TypeError('timeoutMs must be a positive integer');
+    }
     const jobPromise = new Promise((resolve, reject) => {
-        queue.push({ awaitable, resolve, reject });
+        state.queue.push({
+            awaitable: awaitable,
+            resolve: resolve,
+            reject,
+            timeoutMs,
+        });
     });
     if (isInactive) {
         state.running = true;

package/dist/key-helper.d.ts

@@ -1,4 +1,4 @@
-import type { IdentityKeyPair, DHKeyPair } from './types/asymmetric.js';
+import type { IdentityKeyPair, DHKeyPair } from './types/asymmetric';
 export interface SignedPreKey {
     keyId: number;
     keyPair: DHKeyPair;

package/dist/key-helper.js

@@ -1,5 +1,5 @@
 import { randomBytes } from 'crypto';
-import * as curve from './curve.js';
+import * as curve from './curve';
 function isNonNegativeInteger(n) {
     return (typeof n === 'number' &&
         Number.isInteger(n) &&

package/dist/proto/generated/whisper-text-protocol.d.ts

@@ -0,0 +1,29 @@
+export interface WhisperMessage {
+    readonly ephemeralKey?: Uint8Array;
+    readonly counter?: number;
+    readonly previousCounter?: number;
+    readonly ciphertext?: Uint8Array;
+}
+export interface PreKeyWhisperMessage {
+    readonly registrationId?: number;
+    readonly preKeyId?: number;
+    readonly signedPreKeyId?: number;
+    readonly baseKey?: Uint8Array;
+    readonly identityKey?: Uint8Array;
+    readonly message?: Uint8Array;
+}
+export interface KeyExchangeMessage {
+    readonly id?: number;
+    readonly baseKey?: Uint8Array;
+    readonly ephemeralKey?: Uint8Array;
+    readonly identityKey?: Uint8Array;
+    readonly baseKeySignature?: Uint8Array;
+}
+export declare const WhisperMessageCodec: {
+    readonly encode: (message: WhisperMessage) => Uint8Array;
+    readonly decode: (input: Uint8Array) => WhisperMessage;
+};
+export declare const PreKeyWhisperMessageCodec: {
+    readonly encode: (message: PreKeyWhisperMessage) => Uint8Array;
+    readonly decode: (input: Uint8Array) => PreKeyWhisperMessage;
+};

package/dist/proto/generated/whisper-text-protocol.js

@@ -0,0 +1,132 @@
+function varintSize(value) {
+    let size = 1;
+    while (value > 0x7f) {
+        size++;
+        value >>>= 7;
+    }
+    return size;
+}
+function writeVarint(out, offset, value) {
+    while (value > 0x7f) {
+        out[offset++] = (value & 0x7f) | 0x80;
+        value >>>= 7;
+    }
+    out[offset++] = value;
+    return offset;
+}
+function readVarint(input, offset) {
+    let value = 0;
+    let shift = 0;
+    let i = offset;
+    while (i < input.length) {
+        const b = input[i];
+        value |= (b & 0x7f) << shift;
+        i++;
+        if ((b & 0x80) === 0)
+            return [value >>> 0, i];
+        shift += 7;
+    }
+    throw new Error('Malformed varint');
+}
+function skipUnknown(type, input, offset) {
+    if (type === 0) {
+        const [, next] = readVarint(input, offset);
+        return next;
+    }
+    if (type === 2) {
+        const [len, next] = readVarint(input, offset);
+        return next + len;
+    }
+    throw new Error(`Unsupported wire type: ${type}`);
+}
+function decodeMessage(input, bytesMap, varintMap) {
+    const target = {};
+    let offset = 0;
+    while (offset < input.length) {
+        const [header, afterHeader] = readVarint(input, offset);
+        const tag = header >>> 3;
+        const wireType = header & 0x7;
+        offset = afterHeader;
+        const byteField = bytesMap[tag];
+        if (wireType === 2 && byteField) {
+            const [len, next] = readVarint(input, offset);
+            const end = next + len;
+            target[byteField] = input.subarray(next, end);
+            offset = end;
+            continue;
+        }
+        const varintField = varintMap[tag];
+        if (wireType === 0 && varintField) {
+            const [value, next] = readVarint(input, offset);
+            target[varintField] = value;
+            offset = next;
+            continue;
+        }
+        offset = skipUnknown(wireType, input, offset);
+    }
+    return target;
+}
+function encodeFields(message, bytesFields, varintFields) {
+    let size = 0;
+    for (const [tag, key] of bytesFields) {
+        const value = message[key];
+        if (value instanceof Uint8Array) {
+            size += varintSize((tag << 3) | 2) + varintSize(value.length) + value.length;
+        }
+    }
+    for (const [tag, key] of varintFields) {
+        const value = message[key];
+        if (typeof value === 'number') {
+            size += varintSize((tag << 3) | 0) + varintSize(value >>> 0);
+        }
+    }
+    const out = new Uint8Array(size);
+    let offset = 0;
+    for (const [tag, key] of bytesFields) {
+        const value = message[key];
+        if (!(value instanceof Uint8Array))
+            continue;
+        offset = writeVarint(out, offset, (tag << 3) | 2);
+        offset = writeVarint(out, offset, value.length);
+        out.set(value, offset);
+        offset += value.length;
+    }
+    for (const [tag, key] of varintFields) {
+        const value = message[key];
+        if (typeof value !== 'number')
+            continue;
+        offset = writeVarint(out, offset, (tag << 3) | 0);
+        offset = writeVarint(out, offset, value >>> 0);
+    }
+    return out;
+}
+export const WhisperMessageCodec = {
+    encode(message) {
+        return encodeFields(message, [
+            [1, 'ephemeralKey'],
+            [4, 'ciphertext'],
+        ], [
+            [2, 'counter'],
+            [3, 'previousCounter'],
+        ]);
+    },
+    decode(input) {
+        return decodeMessage(input, { 1: 'ephemeralKey', 4: 'ciphertext' }, { 2: 'counter', 3: 'previousCounter' });
+    },
+};
+export const PreKeyWhisperMessageCodec = {
+    encode(message) {
+        return encodeFields(message, [
+            [2, 'baseKey'],
+            [3, 'identityKey'],
+            [4, 'message'],
+        ], [
+            [1, 'preKeyId'],
+            [5, 'registrationId'],
+            [6, 'signedPreKeyId'],
+        ]);
+    },
+    decode(input) {
+        return decodeMessage(input, { 2: 'baseKey', 3: 'identityKey', 4: 'message' }, { 1: 'preKeyId', 5: 'registrationId', 6: 'signedPreKeyId' });
+    },
+};

package/dist/proto/index.d.ts

@@ -0,0 +1 @@
+export { type WhisperMessage, type PreKeyWhisperMessage, type KeyExchangeMessage, WhisperMessageCodec, PreKeyWhisperMessageCodec, } from './generated/whisper-text-protocol';

package/dist/proto/index.js

@@ -0,0 +1 @@
+export { WhisperMessageCodec, PreKeyWhisperMessageCodec, } from './generated/whisper-text-protocol';

package/dist/protobuf.d.ts

@@ -1 +1 @@
-export { PreKeyWhisperMessage, WhisperMessage } from "./generated/WhisperTextProtocol.js";
+export { type WhisperMessage, type PreKeyWhisperMessage, type KeyExchangeMessage, WhisperMessageCodec, PreKeyWhisperMessageCodec, } from './proto';

package/dist/protobuf.js

@@ -1,2 +1 @@
-'use strict';
-export { PreKeyWhisperMessage, WhisperMessage } from "./generated/WhisperTextProtocol.js";
+export { WhisperMessageCodec, PreKeyWhisperMessageCodec, } from './proto';

package/dist/session/builder/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types.js';
-export * from './session-builder.js';
+export * from './types';
+export * from './session-builder';

package/dist/session/builder/index.js

@@ -1,2 +1,2 @@
-export * from './types.js';
-export * from './session-builder.js';
+export * from './types';
+export * from './session-builder';

package/dist/session/builder/session-builder.d.ts

@@ -1,6 +1,6 @@
-import type { ProtocolAddress } from '../../protocol_address.js';
-import { SessionRecord } from '../record/index.js';
-import type { PreKeyBundle, PreKeyWhisperMessage, SessionBuilderStorage } from './types.js';
+import type { ProtocolAddress } from '../../protocol_address';
+import { SessionRecord } from '../record/index';
+import type { PreKeyBundle, PreKeyWhisperMessage, SessionBuilderStorage } from './types';
 export declare class SessionBuilder {
     private readonly addr;
     private readonly storage;

package/dist/session/builder/session-builder.js

@@ -1,9 +1,11 @@
-import { BaseKeyType, ChainType } from "../../ratchet-types.js";
-import { SessionRecord } from '../record/index.js';
-import { crypto } from '../../crypto.js';
-import { signalCrypto } from '../../curve.js';
-import { UntrustedIdentityKeyError, PreKeyError } from '../../signal-errors.js';
-import { enqueue } from '../../job_queue.js';
+import { BaseKeyType, ChainType } from "../../ratchet-types";
+import { SessionRecord } from '../record/index';
+import { crypto } from '../../crypto';
+import { signalCrypto } from '../../curve';
+import { UntrustedIdentityKeyError, PreKeyError } from '../../signal-errors';
+import { enqueue } from '../../job_queue';
+const textEncoder = new TextEncoder();
+const HKDF_INFO_RATCHET = textEncoder.encode('WhisperRatchet');
 export class SessionBuilder {
     addr;
     storage;
@@ -60,7 +62,7 @@ export class SessionBuilder {
             }
             record.setSession(session);
             await this.storage.storeSession(fqAddr, record);
-        });
+        }, { timeoutMs: 30_000 });
     }
     async initIncoming(record, message) {
         const fqAddr = this.addr.toString();
@@ -70,10 +72,12 @@ export class SessionBuilder {
         if (record.getSession(message.baseKey)) {
             return undefined;
         }
-        const [preKeyPair, signedPreKeyPair] = await Promise.all([
-            message.preKeyId ? this.storage.loadPreKey(message.preKeyId) : Promise.resolve(undefined),
-            this.storage.loadSignedPreKey(message.signedPreKeyId)
-        ]);
+        const [preKeyPair, signedPreKeyPair] = this.storage.loadPreKeyPair
+            ? await this.storage.loadPreKeyPair(message.preKeyId, message.signedPreKeyId)
+            : await Promise.all([
+                message.preKeyId ? this.storage.loadPreKey(message.preKeyId) : Promise.resolve(undefined),
+                this.storage.loadSignedPreKey(message.signedPreKeyId)
+            ]);
         if (message.preKeyId && !preKeyPair) {
             throw new PreKeyError('Invalid PreKey ID');
         }
@@ -115,18 +119,17 @@ export class SessionBuilder {
         const masterKey = this.deriveSecrets(sharedSecret, new Uint8Array(32), new TextEncoder().encode('WhisperText'), 2);
         const session = SessionRecord.createEntry();
         session.registrationId = registrationId;
-        const ephemeralKP = isInitiator
-            ? await signalCrypto.generateDHKeyPair().then(kp => ({
-                pubKey: kp.publicKey,
-                privKey: kp.privateKey
-            }))
-            : {
-                pubKey: ourSignedKey.pubKey,
-                privKey: ourSignedKey.privKey
-            };
+        let resolvedEphemeralKP;
+        if (isInitiator) {
+            const kp = await signalCrypto.generateDHKeyPair();
+            resolvedEphemeralKP = { pubKey: kp.publicKey, privKey: kp.privateKey };
+        }
+        else {
+            resolvedEphemeralKP = { pubKey: ourSignedKey.pubKey, privKey: ourSignedKey.privKey };
+        }
         session.currentRatchet = {
             rootKey: masterKey[0],
-            ephemeralKeyPair: ephemeralKP,
+            ephemeralKeyPair: resolvedEphemeralKP,
             lastRemoteEphemeralKey: theirSignedPubKey,
             previousCounter: 0
         };
@@ -146,9 +149,9 @@ export class SessionBuilder {
     calculateSendingRatchet(session, remoteKey) {
         const ratchet = session.currentRatchet;
         const sharedSecret = signalCrypto.calculateAgreement(remoteKey, ratchet.ephemeralKeyPair.privKey);
-        const masterKey = this.deriveSecrets(sharedSecret, ratchet.rootKey, new TextEncoder().encode('WhisperRatchet'), 2);
+        const masterKey = this.deriveSecrets(sharedSecret, ratchet.rootKey, HKDF_INFO_RATCHET, 2);
         session.addChain(ratchet.ephemeralKeyPair.pubKey, {
-            messageKeys: {},
+            messageKeys: new Map(),
             chainKey: {
                 counter: -1,
                 key: masterKey[1]

package/dist/session/builder/types.d.ts

@@ -1,4 +1,5 @@
-import type { SessionRecord } from '../record/index.js';
+import type { SessionRecord } from '../record/index';
+import type { MaybePromise } from '../storage/types';
 export interface PreKeyWhisperMessage {
     identityKey: Uint8Array;
     registrationId: number;
@@ -29,10 +30,11 @@ export interface PreKeyBundle {
     };
 }
 export interface SessionBuilderStorage {
-    isTrustedIdentity(addressName: string, identityKey: Uint8Array): Promise<boolean>;
-    loadSession(addressName: string): Promise<SessionRecord | undefined>;
-    storeSession(addressName: string, record: SessionRecord): Promise<void>;
-    getOurIdentity(): Promise<IdentityKeyPair>;
-    loadPreKey(preKeyId: number): Promise<KeyPair | undefined>;
-    loadSignedPreKey(signedPreKeyId: number): Promise<KeyPair | undefined>;
+    isTrustedIdentity(addressName: string, identityKey: Uint8Array): MaybePromise<boolean>;
+    loadSession(addressName: string): MaybePromise<SessionRecord | undefined>;
+    storeSession(addressName: string, record: SessionRecord): MaybePromise<void>;
+    getOurIdentity(): MaybePromise<IdentityKeyPair>;
+    loadPreKey(preKeyId: number): MaybePromise<KeyPair | undefined>;
+    loadSignedPreKey(signedPreKeyId: number): MaybePromise<KeyPair | undefined>;
+    loadPreKeyPair?(preKeyId: number | undefined, signedPreKeyId: number): MaybePromise<readonly [KeyPair | undefined, KeyPair | undefined]>;
 }

package/dist/session/cipher/encoding.d.ts

@@ -1,13 +1,9 @@
-import type { WhisperMessageProto, PreKeyWhisperMessageProto } from './types.js';
+import type { WhisperMessageProto, PreKeyWhisperMessageProto } from './types';
 export declare class WhisperMessageEncoder {
     static encodeWhisperMessage(msg: WhisperMessageProto): Uint8Array;
     static decodeWhisperMessage(buf: Uint8Array): WhisperMessageProto;
     static encodePreKeyWhisperMessage(msg: PreKeyWhisperMessageProto): Uint8Array;
     static decodePreKeyWhisperMessage(buf: Uint8Array): PreKeyWhisperMessageProto;
-    private static encodeFieldVarint;
-    private static encodeFieldBytes;
-    private static encodeVarint;
-    private static decodeVarint;
-    private static decodeFieldHeader;
-    private static concatUint8Arrays;
+    private static validateWhisper;
+    private static validatePreKey;
 }