@unknownncat/swt-libsignal 1.0.4

package/dist/base_key_type.d.ts

@@ -0,0 +1,5 @@
+export declare const BaseKeyType: {
+    readonly OURS: 1;
+    readonly THEIRS: 2;
+};
+export type BaseKeyType = typeof BaseKeyType[keyof typeof BaseKeyType];

package/dist/base_key_type.js

@@ -0,0 +1,4 @@
+export const BaseKeyType = {
+    OURS: 1,
+    THEIRS: 2
+};

package/dist/chain_type.d.ts

@@ -0,0 +1,5 @@
+export declare const ChainType: {
+    readonly SENDING: 1;
+    readonly RECEIVING: 2;
+};
+export type BaseChainType = typeof ChainType[keyof typeof ChainType];

package/dist/chain_type.js

@@ -0,0 +1,4 @@
+export const ChainType = {
+    SENDING: 1,
+    RECEIVING: 2
+};

package/dist/crypto.d.ts

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

package/dist/crypto.js

@@ -0,0 +1,95 @@
+import { createCipheriv, createDecipheriv, createHmac, createHash, randomBytes } from 'node:crypto';
+const EMPTY_BUFFER = Buffer.alloc(0);
+function toBuffer(data) {
+    return Buffer.isBuffer(data)
+        ? data
+        : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+}
+function toUint8(data) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+async function encrypt(key, plaintext, options) {
+    const k = toBuffer(key);
+    if (k.length !== 32) {
+        throw new Error('Key must be 32 bytes');
+    }
+    const iv = options?.iv
+        ? toBuffer(options.iv)
+        : randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', k, iv);
+    if (options?.aad) {
+        cipher.setAAD(toBuffer(options.aad));
+    }
+    const plainBuf = toBuffer(plaintext);
+    const encrypted = cipher.update(plainBuf);
+    const final = cipher.final();
+    const ciphertext = encrypted.length === 0
+        ? final
+        : encrypted.length === final.length
+            ? Buffer.concat([encrypted, final], encrypted.length + final.length)
+            : Buffer.concat([encrypted, final]);
+    const tag = cipher.getAuthTag();
+    return {
+        ciphertext: toUint8(ciphertext),
+        iv: toUint8(iv),
+        tag: toUint8(tag)
+    };
+}
+async function decrypt(key, data, options) {
+    const k = toBuffer(key);
+    const decipher = createDecipheriv('aes-256-gcm', k, toBuffer(data.iv));
+    if (options?.aad) {
+        decipher.setAAD(toBuffer(options.aad));
+    }
+    decipher.setAuthTag(toBuffer(data.tag));
+    const cipherBuf = toBuffer(data.ciphertext);
+    const decrypted = decipher.update(cipherBuf);
+    const final = decipher.final();
+    const plaintext = decrypted.length === 0
+        ? final
+        : decrypted.length === final.length
+            ? Buffer.concat([decrypted, final], decrypted.length + final.length)
+            : Buffer.concat([decrypted, final]);
+    return toUint8(plaintext);
+}
+function hkdf(ikm, salt, info, options) {
+    const length = options.length;
+    const hashLen = 32;
+    const blocksNeeded = Math.ceil(length / hashLen);
+    const prk = createHmac('sha256', toBuffer(salt))
+        .update(toBuffer(ikm))
+        .digest();
+    const output = Buffer.allocUnsafe(length);
+    const infoBuf = toBuffer(info);
+    let prev = EMPTY_BUFFER;
+    const infoWithCounter = Buffer.allocUnsafe(infoBuf.length + 1);
+    infoBuf.copy(infoWithCounter, 0);
+    for (let i = 0; i < blocksNeeded; i++) {
+        const hmac = createHmac('sha256', prk);
+        if (prev.length)
+            hmac.update(prev);
+        hmac.update(infoWithCounter.subarray(0, infoBuf.length));
+        infoWithCounter[infoBuf.length] = i + 1;
+        prev = hmac.digest();
+        const copyLen = Math.min(hashLen, length - i * hashLen);
+        prev.copy(output, i * hashLen, 0, copyLen);
+    }
+    return toUint8(output);
+}
+function sha512(data) {
+    return toUint8(createHash('sha512')
+        .update(toBuffer(data))
+        .digest());
+}
+function hmacSha256(key, data) {
+    return toUint8(createHmac('sha256', toBuffer(key))
+        .update(toBuffer(data))
+        .digest());
+}
+export const crypto = {
+    encrypt,
+    decrypt,
+    hkdf,
+    sha512,
+    hmacSha256
+};

package/dist/curve.d.ts

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

package/dist/curve.js

@@ -0,0 +1,67 @@
+import libsodium from 'libsodium-wrappers';
+let sodiumReady = null;
+function ensureReady() {
+    if (!sodiumReady) {
+        sodiumReady = libsodium.ready;
+    }
+    return sodiumReady;
+}
+function assertLength(data, expected, name) {
+    if (data.length !== expected) {
+        throw new Error(`${name} must be ${expected} bytes`);
+    }
+}
+async function generateIdentityKeyPair() {
+    await ensureReady();
+    const kp = libsodium.crypto_sign_keypair();
+    return {
+        publicKey: kp.publicKey,
+        privateKey: kp.privateKey
+    };
+}
+function sign(privateKey, message) {
+    assertLength(privateKey, 64, 'Ed25519 private key');
+    return libsodium.crypto_sign_detached(message, privateKey);
+}
+function verify(publicKey, message, signature) {
+    assertLength(publicKey, 32, 'Ed25519 public key');
+    assertLength(signature, 64, 'Signature');
+    return libsodium.crypto_sign_verify_detached(signature, message, publicKey);
+}
+async function generateDHKeyPair() {
+    await ensureReady();
+    const kp = libsodium.crypto_kx_keypair();
+    return {
+        publicKey: kp.publicKey,
+        privateKey: kp.privateKey
+    };
+}
+function calculateAgreement(publicKey, privateKey) {
+    assertLength(publicKey, 32, 'X25519 public key');
+    assertLength(privateKey, 32, 'X25519 private key');
+    return libsodium.crypto_scalarmult(privateKey, publicKey);
+}
+function convertIdentityPublicToX25519(edPublicKey) {
+    assertLength(edPublicKey, 32, 'Ed25519 public key');
+    return libsodium.crypto_sign_ed25519_pk_to_curve25519(edPublicKey);
+}
+function convertIdentityPrivateToX25519(edPrivateKey) {
+    assertLength(edPrivateKey, 64, 'Ed25519 private key');
+    return libsodium.crypto_sign_ed25519_sk_to_curve25519(edPrivateKey);
+}
+async function generateKeyPair() {
+    return generateDHKeyPair();
+}
+function calculateSignature(identityPrivateKey, data) {
+    return sign(identityPrivateKey, data);
+}
+export const signalCrypto = {
+    generateIdentityKeyPair,
+    sign,
+    verify,
+    generateDHKeyPair,
+    calculateAgreement,
+    convertIdentityPublicToX25519,
+    convertIdentityPrivateToX25519
+};
+export { generateKeyPair, calculateSignature };

package/dist/fingerprint.d.ts

@@ -0,0 +1,5 @@
+export declare class FingerprintGenerator {
+    private readonly iterations;
+    constructor(iterations: number);
+    createFor(localIdentifier: string, localIdentityKey: Uint8Array, remoteIdentifier: string, remoteIdentityKey: Uint8Array): string;
+}

package/dist/fingerprint.js

@@ -0,0 +1,76 @@
+import { crypto } from './crypto.js';
+const VERSION = 0;
+function numberToUint16BE(num) {
+    const out = new Uint8Array(2);
+    out[0] = num >> 8;
+    out[1] = num & 0xff;
+    return out;
+}
+function concatBytes(...arrays) {
+    const total = arrays.reduce((sum, a) => sum + (a?.length ?? 0), 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const arr of arrays) {
+        if (arr) {
+            result.set(arr, offset);
+            offset += arr.length;
+        }
+    }
+    return result;
+}
+function stringToUtf8(str) {
+    return new TextEncoder().encode(str);
+}
+function iterateHash(data, key, count) {
+    let result = data;
+    for (let i = 0; i < count; i++) {
+        result = crypto.sha512(concatBytes(result, key));
+    }
+    return result;
+}
+function getEncodedChunk(hash, offset) {
+    if (hash.length < offset + 5) {
+        throw new Error('Hash output too small');
+    }
+    const chunk = (hash[offset] * 2 ** 32 +
+        hash[offset + 1] * 2 ** 24 +
+        hash[offset + 2] * 2 ** 16 +
+        hash[offset + 3] * 2 ** 8 +
+        hash[offset + 4]) % 100000;
+    return chunk.toString().padStart(5, '0');
+}
+function getDisplayStringFor(identifier, key, iterations) {
+    const versionBytes = numberToUint16BE(VERSION);
+    const combined = concatBytes(versionBytes, key, stringToUtf8(identifier));
+    const output = iterateHash(combined, key, iterations);
+    return (getEncodedChunk(output, 0) +
+        getEncodedChunk(output, 5) +
+        getEncodedChunk(output, 10) +
+        getEncodedChunk(output, 15) +
+        getEncodedChunk(output, 20) +
+        getEncodedChunk(output, 25));
+}
+export class FingerprintGenerator {
+    iterations;
+    constructor(iterations) {
+        if (!Number.isInteger(iterations) || iterations <= 0) {
+            throw new Error('iterations must be a positive integer');
+        }
+        this.iterations = iterations;
+    }
+    createFor(localIdentifier, localIdentityKey, remoteIdentifier, remoteIdentityKey) {
+        if (typeof localIdentifier !== 'string' ||
+            typeof remoteIdentifier !== 'string') {
+            throw new Error('Identifiers must be strings');
+        }
+        if (!(localIdentityKey instanceof Uint8Array) ||
+            !(remoteIdentityKey instanceof Uint8Array)) {
+            throw new Error('Identity keys must be Uint8Array');
+        }
+        const localFp = getDisplayStringFor(localIdentifier, localIdentityKey, this.iterations);
+        const remoteFp = getDisplayStringFor(remoteIdentifier, remoteIdentityKey, this.iterations);
+        return [localFp, remoteFp]
+            .sort()
+            .join('');
+    }
+}

package/dist/generated/WhisperTextProtocol.d.ts

@@ -0,0 +1,49 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+export interface WhisperMessage {
+    ephemeralKey?: Uint8Array;
+    counter?: number;
+    previousCounter?: number;
+    ciphertext?: Uint8Array;
+}
+export interface PreKeyWhisperMessage {
+    registrationId?: number;
+    preKeyId?: number;
+    signedPreKeyId?: number;
+    baseKey?: Uint8Array;
+    identityKey?: Uint8Array;
+    message?: Uint8Array;
+}
+export interface KeyExchangeMessage {
+    id?: number;
+    baseKey?: Uint8Array;
+    ephemeralKey?: Uint8Array;
+    identityKey?: Uint8Array;
+    baseKeySignature?: Uint8Array;
+}
+declare class WhisperMessage$Type extends MessageType<WhisperMessage> {
+    constructor();
+    create(value?: PartialMessage<WhisperMessage>): WhisperMessage;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WhisperMessage): WhisperMessage;
+    internalBinaryWrite(message: WhisperMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+export declare const WhisperMessage: WhisperMessage$Type;
+declare class PreKeyWhisperMessage$Type extends MessageType<PreKeyWhisperMessage> {
+    constructor();
+    create(value?: PartialMessage<PreKeyWhisperMessage>): PreKeyWhisperMessage;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PreKeyWhisperMessage): PreKeyWhisperMessage;
+    internalBinaryWrite(message: PreKeyWhisperMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+export declare const PreKeyWhisperMessage: PreKeyWhisperMessage$Type;
+declare class KeyExchangeMessage$Type extends MessageType<KeyExchangeMessage> {
+    constructor();
+    create(value?: PartialMessage<KeyExchangeMessage>): KeyExchangeMessage;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeyExchangeMessage): KeyExchangeMessage;
+    internalBinaryWrite(message: KeyExchangeMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+export declare const KeyExchangeMessage: KeyExchangeMessage$Type;
+export {};

package/dist/generated/WhisperTextProtocol.js

@@ -0,0 +1,199 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+class WhisperMessage$Type extends MessageType {
+    constructor() {
+        super("textsecure.WhisperMessage", [
+            { no: 1, name: "ephemeral_key", kind: "scalar", opt: true, T: 12 },
+            { no: 2, name: "counter", kind: "scalar", opt: true, T: 13 },
+            { no: 3, name: "previous_counter", kind: "scalar", opt: true, T: 13 },
+            { no: 4, name: "ciphertext", kind: "scalar", opt: true, T: 12 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    message.ephemeralKey = reader.bytes();
+                    break;
+                case 2:
+                    message.counter = reader.uint32();
+                    break;
+                case 3:
+                    message.previousCounter = reader.uint32();
+                    break;
+                case 4:
+                    message.ciphertext = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        if (message.ephemeralKey !== undefined)
+            writer.tag(1, WireType.LengthDelimited).bytes(message.ephemeralKey);
+        if (message.counter !== undefined)
+            writer.tag(2, WireType.Varint).uint32(message.counter);
+        if (message.previousCounter !== undefined)
+            writer.tag(3, WireType.Varint).uint32(message.previousCounter);
+        if (message.ciphertext !== undefined)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.ciphertext);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+export const WhisperMessage = new WhisperMessage$Type();
+class PreKeyWhisperMessage$Type extends MessageType {
+    constructor() {
+        super("textsecure.PreKeyWhisperMessage", [
+            { no: 5, name: "registration_id", kind: "scalar", opt: true, T: 13 },
+            { no: 1, name: "pre_key_id", kind: "scalar", opt: true, T: 13 },
+            { no: 6, name: "signed_pre_key_id", kind: "scalar", opt: true, T: 13 },
+            { no: 2, name: "base_key", kind: "scalar", opt: true, T: 12 },
+            { no: 3, name: "identity_key", kind: "scalar", opt: true, T: 12 },
+            { no: 4, name: "message", kind: "scalar", opt: true, T: 12 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 5:
+                    message.registrationId = reader.uint32();
+                    break;
+                case 1:
+                    message.preKeyId = reader.uint32();
+                    break;
+                case 6:
+                    message.signedPreKeyId = reader.uint32();
+                    break;
+                case 2:
+                    message.baseKey = reader.bytes();
+                    break;
+                case 3:
+                    message.identityKey = reader.bytes();
+                    break;
+                case 4:
+                    message.message = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        if (message.preKeyId !== undefined)
+            writer.tag(1, WireType.Varint).uint32(message.preKeyId);
+        if (message.baseKey !== undefined)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.baseKey);
+        if (message.identityKey !== undefined)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.identityKey);
+        if (message.message !== undefined)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.message);
+        if (message.registrationId !== undefined)
+            writer.tag(5, WireType.Varint).uint32(message.registrationId);
+        if (message.signedPreKeyId !== undefined)
+            writer.tag(6, WireType.Varint).uint32(message.signedPreKeyId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+export const PreKeyWhisperMessage = new PreKeyWhisperMessage$Type();
+class KeyExchangeMessage$Type extends MessageType {
+    constructor() {
+        super("textsecure.KeyExchangeMessage", [
+            { no: 1, name: "id", kind: "scalar", opt: true, T: 13 },
+            { no: 2, name: "base_key", kind: "scalar", opt: true, T: 12 },
+            { no: 3, name: "ephemeral_key", kind: "scalar", opt: true, T: 12 },
+            { no: 4, name: "identity_key", kind: "scalar", opt: true, T: 12 },
+            { no: 5, name: "base_key_signature", kind: "scalar", opt: true, T: 12 }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    message.id = reader.uint32();
+                    break;
+                case 2:
+                    message.baseKey = reader.bytes();
+                    break;
+                case 3:
+                    message.ephemeralKey = reader.bytes();
+                    break;
+                case 4:
+                    message.identityKey = reader.bytes();
+                    break;
+                case 5:
+                    message.baseKeySignature = reader.bytes();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        if (message.id !== undefined)
+            writer.tag(1, WireType.Varint).uint32(message.id);
+        if (message.baseKey !== undefined)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.baseKey);
+        if (message.ephemeralKey !== undefined)
+            writer.tag(3, WireType.LengthDelimited).bytes(message.ephemeralKey);
+        if (message.identityKey !== undefined)
+            writer.tag(4, WireType.LengthDelimited).bytes(message.identityKey);
+        if (message.baseKeySignature !== undefined)
+            writer.tag(5, WireType.LengthDelimited).bytes(message.baseKeySignature);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+export const KeyExchangeMessage = new KeyExchangeMessage$Type();

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+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 { ChainType } from './chain_type.js';
+export { BaseKeyType } from './base_key_type.js';
+export type { BaseKeyType as BaseKeyTypeValue } from './base_key_type.js';
+export { PreKeyWhisperMessage, WhisperMessage } from './protobuf.js';
+export { enqueue } from './job_queue.js';

package/dist/index.js

@@ -0,0 +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 { ChainType } from './chain_type.js';
+export { BaseKeyType } from './base_key_type.js';
+export { PreKeyWhisperMessage, WhisperMessage } from './protobuf.js';
+export { enqueue } from './job_queue.js';

package/dist/job_queue.d.ts

@@ -0,0 +1,3 @@
+type Awaitable<T> = () => Promise<T>;
+export declare function enqueue<T>(bucket: unknown, awaitable: Awaitable<T>): Promise<T>;
+export {};

package/dist/job_queue.js

@@ -0,0 +1,48 @@
+const queueBuckets = new Map();
+const GC_LIMIT = 10_000;
+async function asyncQueueExecutor(bucket, state) {
+    const queue = state.queue;
+    while (state.offset < queue.length) {
+        const limit = Math.min(queue.length, state.offset + GC_LIMIT);
+        for (let i = state.offset; i < limit; i++) {
+            const job = queue[i];
+            if (!job)
+                continue;
+            try {
+                const result = await job.awaitable();
+                job.resolve(result);
+            }
+            catch (err) {
+                job.reject(err);
+            }
+        }
+        state.offset = limit;
+        if (limit < queue.length) {
+            queue.splice(0, limit);
+            state.offset = 0;
+        }
+    }
+    state.running = false;
+    queueBuckets.delete(bucket);
+}
+export function enqueue(bucket, awaitable) {
+    let state = queueBuckets.get(bucket);
+    const isInactive = !state;
+    if (!state) {
+        state = {
+            queue: [],
+            offset: 0,
+            running: false
+        };
+        queueBuckets.set(bucket, state);
+    }
+    const queue = state.queue;
+    const jobPromise = new Promise((resolve, reject) => {
+        queue.push({ awaitable, resolve, reject });
+    });
+    if (isInactive) {
+        state.running = true;
+        void asyncQueueExecutor(bucket, state);
+    }
+    return jobPromise;
+}

package/dist/key-helper.d.ts

@@ -0,0 +1,14 @@
+import type { IdentityKeyPair, DHKeyPair } from '../types/asymmetric.js';
+export interface SignedPreKey {
+    keyId: number;
+    keyPair: DHKeyPair;
+    signature: Uint8Array;
+}
+export interface PreKey {
+    keyId: number;
+    keyPair: DHKeyPair;
+}
+export declare const generateIdentityKeyPair: () => Promise<IdentityKeyPair>;
+export declare function generateRegistrationId(): number;
+export declare function generateSignedPreKey(identityKeyPair: IdentityKeyPair, signedKeyId: number): Promise<SignedPreKey>;
+export declare function generatePreKey(keyId: number): Promise<PreKey>;