@neykoor/libsignal-node 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neykoor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+<div align="center">
+
+<img src="./assets/banner.png" alt="libsignal-node-ts banner" width="100%" />
+
+# libsignal-node-ts
+
+**Port 100% TypeScript de `libsignal-node`, compatible con [BaileysX](https://github.com/Neykoor/BaileysX)**
+
+[![npm](https://img.shields.io/badge/npm-libsignal--node--ts-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/libsignal-node-ts)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.6-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![ESM](https://img.shields.io/badge/Module-ESM-yellow)](https://nodejs.org/api/esm.html)
+[![Node](https://img.shields.io/badge/Node-%3E%3D20-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![License](https://img.shields.io/badge/License-MIT-blue)](./LICENSE)
+[![Status](https://img.shields.io/badge/Estado-Estable-success)]()
+
+</div>
+
+---
+
+## ✨ ¿Qué es esto?
+
+`libsignal-node-ts` es una reescritura completa en **TypeScript** de la librería [`libsignal-node`](https://github.com/this-xys/libsignal-node) (Signal Protocol / Double Ratchet), pensada como **reemplazo directo** de la dependencia `libsignal` que usa BaileysX.
+
+Mismo API, misma criptografía, cero `@ts-ignore`, tipado de punta a punta.
+
+## 🚀 Características
+
+- 🔒 Implementación completa del **Double Ratchet** (X3DH, sesiones, ratcheting)
+- 📦 Tipado estricto (`strict: true`, `noUncheckedIndexedAccess`)
+- ⚡ ESM nativo
+- 🔁 API idéntica a `libsignal-node` — `ProtocolAddress`, `SessionBuilder`, `SessionCipher`, `SessionRecord`
+- 🧩 Drop-in: solo cambias el import, no tocas el resto de tu código
+
+## 📦 Instalación
+
+```bash
+npm install libsignal-node-ts
+```
+
+Dependencias en tiempo de ejecución: `curve25519-js` y `protobufjs` (se instalan solas junto con el paquete).
+
+## 📂 Estructura del código fuente
+
+```
+libsignal-node-ts/
+├── src/
+│   ├── index.ts                     # punto de entrada
+│   ├── protocol-address.ts
+│   ├── session-builder.ts
+│   ├── session-cipher.ts
+│   ├── session-record.ts
+│   ├── curve.ts
+│   ├── curve25519-js.d.ts
+│   ├── crypto.ts
+│   ├── keyhelper.ts
+│   ├── numeric-fingerprint.ts
+│   ├── prekey-bundle-validator.ts
+│   ├── memory-storage.ts
+│   ├── logger.ts
+│   ├── errors.ts
+│   ├── direction.ts
+│   ├── base-key-type.ts
+│   ├── chain-type.ts
+│   ├── queue-job.ts
+│   ├── types.ts
+│   ├── protobufs.ts
+│   ├── whisper-text-protocol.js     # protobufs generados (ESM)
+│   └── whisper-text-protocol.d.ts
+├── lib/                              # salida compilada (lo que se publica en npm)
+├── package.json
+└── tsconfig.json
+```
+
+## 🔧 Uso en BaileysX
+
+En `src/Signal/libsignal.ts`, reemplaza:
+
+```ts
+// @ts-ignore
+import * as libsignal from 'libsignal'
+// @ts-ignore
+import { PreKeyWhisperMessage } from 'libsignal/lib/protobufs.js'
+```
+
+por:
+
+```ts
+import * as libsignal from 'libsignal-node-ts'
+import { protobufs } from 'libsignal-node-ts'
+const { PreKeyWhisperMessage } = protobufs
+```
+
+Y en el `package.json` de tu proyecto, quita la dependencia `libsignal` y agrega:
+
+```json
+"libsignal-node-ts": "^1.0.0"
+```
+
+## 📖 Uso básico
+
+```ts
+import { ProtocolAddress, SessionBuilder, SessionCipher, MemorySignalStorage, keyhelper } from 'libsignal-node-ts'
+
+const identityKeyPair = keyhelper.generateIdentityKeyPair()
+const registrationId = keyhelper.generateRegistrationId()
+const storage = new MemorySignalStorage(identityKeyPair, registrationId)
+const addr = new ProtocolAddress('5215512345678', 1)
+
+const builder = new SessionBuilder(storage, addr)
+await builder.initOutgoing(deviceBundle)
+
+const cipher = new SessionCipher(storage, addr)
+const { type, body } = await cipher.encrypt(Buffer.from('hola mundo'))
+```
+
+`storage` debe implementar la interfaz `SignalStorage` exportada desde el paquete (o puedes usar `MemorySignalStorage`, incluida para pruebas rápidas y almacenamiento en memoria).
+
+## 🧪 Compilar desde el código fuente
+
+```bash
+npm run build
+```
+
+Compila `src/` a `lib/` con `tsc` en modo `strict` y corrige las extensiones `.js` de los imports ESM con `tsc-esm-fix`.
+
+---
+
+<div align="center">
+Hecho con ☕ para el ecosistema <b>Eris-MD</b> / <b>BaileysX</b>
+</div>

package/lib/base-key-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum BaseKeyType {
+    OURS = 1,
+    THEIRS = 2
+}

package/lib/base-key-type.js

@@ -0,0 +1,5 @@
+export var BaseKeyType;
+(function (BaseKeyType) {
+    BaseKeyType[BaseKeyType["OURS"] = 1] = "OURS";
+    BaseKeyType[BaseKeyType["THEIRS"] = 2] = "THEIRS";
+})(BaseKeyType || (BaseKeyType = {}));

package/lib/chain-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum ChainType {
+    SENDING = 1,
+    RECEIVING = 2
+}

package/lib/chain-type.js

@@ -0,0 +1,5 @@
+export var ChainType;
+(function (ChainType) {
+    ChainType[ChainType["SENDING"] = 1] = "SENDING";
+    ChainType[ChainType["RECEIVING"] = 2] = "RECEIVING";
+})(ChainType || (ChainType = {}));

package/lib/crypto.d.ts

@@ -0,0 +1,6 @@
+export declare function encrypt(key: Uint8Array, data: Uint8Array, iv: Uint8Array): Buffer;
+export declare function decrypt(key: Uint8Array, data: Uint8Array, iv: Uint8Array): Buffer;
+export declare function calculateMAC(key: Uint8Array, data: Uint8Array): Buffer;
+export declare function hash(data: Uint8Array): Buffer;
+export declare function deriveSecrets(input: Uint8Array, salt: Uint8Array, info: Uint8Array, chunks?: number): Buffer[];
+export declare function verifyMAC(data: Uint8Array, key: Uint8Array, mac: Uint8Array, length: number): void;

package/lib/crypto.js

@@ -0,0 +1,73 @@
+import * as nodeCrypto from 'crypto';
+function assertBuffer(value) {
+    if (!(value instanceof Uint8Array)) {
+        throw TypeError(`Expected Uint8Array instead of: ${value?.constructor?.name}`);
+    }
+    return value;
+}
+export function encrypt(key, data, iv) {
+    assertBuffer(key);
+    assertBuffer(data);
+    assertBuffer(iv);
+    const cipher = nodeCrypto.createCipheriv('aes-256-cbc', key, iv);
+    return Buffer.concat([cipher.update(data), cipher.final()]);
+}
+export function decrypt(key, data, iv) {
+    assertBuffer(key);
+    assertBuffer(data);
+    assertBuffer(iv);
+    const decipher = nodeCrypto.createDecipheriv('aes-256-cbc', key, iv);
+    return Buffer.concat([decipher.update(data), decipher.final()]);
+}
+export function calculateMAC(key, data) {
+    assertBuffer(key);
+    assertBuffer(data);
+    const hmac = nodeCrypto.createHmac('sha256', key);
+    hmac.update(data);
+    return Buffer.from(hmac.digest());
+}
+export function hash(data) {
+    assertBuffer(data);
+    const sha512 = nodeCrypto.createHash('sha512');
+    sha512.update(data);
+    return sha512.digest();
+}
+export function deriveSecrets(input, salt, info, chunks) {
+    assertBuffer(input);
+    assertBuffer(salt);
+    assertBuffer(info);
+    if (salt.byteLength !== 32) {
+        throw new Error('Got salt of incorrect length');
+    }
+    const count = chunks || 3;
+    if (count < 1 || count > 3) {
+        throw new Error('chunks must be between 1 and 3');
+    }
+    const PRK = calculateMAC(salt, input);
+    const infoArray = new Uint8Array(info.byteLength + 1 + 32);
+    infoArray.set(info, 32);
+    infoArray[infoArray.length - 1] = 1;
+    const signed = [calculateMAC(PRK, Buffer.from(infoArray.slice(32)))];
+    if (count > 1) {
+        infoArray.set(signed[signed.length - 1]);
+        infoArray[infoArray.length - 1] = 2;
+        signed.push(calculateMAC(PRK, Buffer.from(infoArray)));
+    }
+    if (count > 2) {
+        infoArray.set(signed[signed.length - 1]);
+        infoArray[infoArray.length - 1] = 3;
+        signed.push(calculateMAC(PRK, Buffer.from(infoArray)));
+    }
+    PRK.fill(0);
+    infoArray.fill(0);
+    return signed;
+}
+export function verifyMAC(data, key, mac, length) {
+    const calculatedMac = calculateMAC(key, data).slice(0, length);
+    if (mac.length !== length || calculatedMac.length !== length) {
+        throw new Error('Bad MAC length');
+    }
+    if (!nodeCrypto.timingSafeEqual(mac, calculatedMac)) {
+        throw new Error('Bad MAC');
+    }
+}

package/lib/curve.d.ts

@@ -0,0 +1,9 @@
+export interface KeyPair {
+    pubKey: Buffer;
+    privKey: Buffer;
+}
+export declare function getPublicFromPrivateKey(privKey: Uint8Array): Buffer;
+export declare function generateKeyPair(): KeyPair;
+export declare function calculateAgreement(pubKeyInput: Uint8Array, privKey: Uint8Array): Buffer;
+export declare function calculateSignature(privKey: Uint8Array, message: Uint8Array): Buffer;
+export declare function verifySignature(pubKeyInput: Uint8Array, msg: Uint8Array, sig: Uint8Array): boolean;

package/lib/curve.js

@@ -0,0 +1,112 @@
+import * as curveJs from 'curve25519-js';
+import * as nodeCrypto from 'crypto';
+import { getLogger } from './logger.js';
+const PUBLIC_KEY_DER_PREFIX = Buffer.from([48, 42, 48, 5, 6, 3, 43, 101, 110, 3, 33, 0]);
+const PRIVATE_KEY_DER_PREFIX = Buffer.from([48, 46, 2, 1, 0, 48, 5, 6, 3, 43, 101, 110, 4, 34, 4, 32]);
+const KEY_BUNDLE_TYPE = Buffer.from([5]);
+function prefixKeyInPublicKey(pubKey) {
+    return Buffer.concat([KEY_BUNDLE_TYPE, pubKey]);
+}
+function validatePrivKey(privKey) {
+    if (privKey === undefined) {
+        throw new Error('Undefined private key');
+    }
+    if (!(privKey instanceof Uint8Array)) {
+        throw new Error(`Invalid private key type: ${privKey.constructor.name}`);
+    }
+    if (privKey.byteLength !== 32) {
+        throw new Error(`Incorrect private key length: ${privKey.byteLength}`);
+    }
+}
+function scrubPubKeyFormat(pubKey) {
+    if (!(pubKey instanceof Uint8Array)) {
+        throw new Error(`Invalid public key type: ${pubKey.constructor.name}`);
+    }
+    if (pubKey === undefined || ((pubKey.byteLength !== 33 || pubKey[0] !== 5) && pubKey.byteLength !== 32)) {
+        throw new Error('Invalid public key');
+    }
+    if (pubKey.byteLength === 33) {
+        return Buffer.from(pubKey.slice(1));
+    }
+    getLogger().warn('Expected pubkey of length 33, please report the ST and client that generated the pubkey');
+    return Buffer.from(pubKey);
+}
+function unclampEd25519PrivateKey(clampedSk) {
+    const unclampedSk = new Uint8Array(clampedSk);
+    unclampedSk[0] = unclampedSk[0] | 6;
+    unclampedSk[31] = unclampedSk[31] | 128;
+    unclampedSk[31] = unclampedSk[31] & ~64;
+    return unclampedSk;
+}
+export function getPublicFromPrivateKey(privKey) {
+    const unclampedPK = unclampEd25519PrivateKey(privKey);
+    const keyPair = curveJs.generateKeyPair(unclampedPK);
+    return prefixKeyInPublicKey(Buffer.from(keyPair.public));
+}
+export function generateKeyPair() {
+    try {
+        const { publicKey: publicDerBytes, privateKey: privateDerBytes } = nodeCrypto.generateKeyPairSync('x25519', {
+            publicKeyEncoding: { format: 'der', type: 'spki' },
+            privateKeyEncoding: { format: 'der', type: 'pkcs8' }
+        });
+        const pubKey = publicDerBytes.slice(PUBLIC_KEY_DER_PREFIX.length, PUBLIC_KEY_DER_PREFIX.length + 32);
+        const privKey = privateDerBytes.slice(PRIVATE_KEY_DER_PREFIX.length, PRIVATE_KEY_DER_PREFIX.length + 32);
+        return {
+            pubKey: prefixKeyInPublicKey(pubKey),
+            privKey
+        };
+    }
+    catch (e) {
+        getLogger().debug(`x25519 native keygen failed, falling back to curve25519-js: ${e?.message}`);
+        const keyPair = curveJs.generateKeyPair(nodeCrypto.randomBytes(32));
+        return {
+            privKey: Buffer.from(keyPair.private),
+            pubKey: prefixKeyInPublicKey(Buffer.from(keyPair.public))
+        };
+    }
+}
+export function calculateAgreement(pubKeyInput, privKey) {
+    const pubKey = scrubPubKeyFormat(pubKeyInput);
+    validatePrivKey(privKey);
+    if (!pubKey || pubKey.byteLength !== 32) {
+        throw new Error('Invalid public key');
+    }
+    if (typeof nodeCrypto.diffieHellman === 'function') {
+        const nodePrivateKey = nodeCrypto.createPrivateKey({
+            key: Buffer.concat([PRIVATE_KEY_DER_PREFIX, privKey]),
+            format: 'der',
+            type: 'pkcs8'
+        });
+        const nodePublicKey = nodeCrypto.createPublicKey({
+            key: Buffer.concat([PUBLIC_KEY_DER_PREFIX, pubKey]),
+            format: 'der',
+            type: 'spki'
+        });
+        return nodeCrypto.diffieHellman({
+            privateKey: nodePrivateKey,
+            publicKey: nodePublicKey
+        });
+    }
+    const secret = curveJs.sharedKey(privKey, pubKey);
+    return Buffer.from(secret);
+}
+export function calculateSignature(privKey, message) {
+    validatePrivKey(privKey);
+    if (!message) {
+        throw new Error('Invalid message');
+    }
+    return Buffer.from(curveJs.sign(privKey, message));
+}
+export function verifySignature(pubKeyInput, msg, sig) {
+    const pubKey = scrubPubKeyFormat(pubKeyInput);
+    if (!pubKey || pubKey.byteLength !== 32) {
+        throw new Error('Invalid public key');
+    }
+    if (!msg) {
+        throw new Error('Invalid message');
+    }
+    if (!sig || sig.byteLength !== 64) {
+        throw new Error('Invalid signature');
+    }
+    return curveJs.verify(pubKey, msg, sig);
+}

package/lib/direction.d.ts

@@ -0,0 +1,4 @@
+export declare enum Direction {
+    SENDING = 1,
+    RECEIVING = 2
+}

package/lib/direction.js

@@ -0,0 +1,5 @@
+export var Direction;
+(function (Direction) {
+    Direction[Direction["SENDING"] = 1] = "SENDING";
+    Direction[Direction["RECEIVING"] = 2] = "RECEIVING";
+})(Direction || (Direction = {}));

package/lib/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class SignalError extends Error {
+}
+export declare class UntrustedIdentityKeyError extends SignalError {
+    addr: string;
+    identityKey?: Buffer;
+    constructor(addr: string, identityKey?: Buffer);
+}
+export declare class SessionError extends SignalError {
+    constructor(message?: string);
+}
+export declare class MessageCounterError extends SessionError {
+    constructor(message?: string);
+}
+export declare class PreKeyError extends SessionError {
+    constructor(message?: string);
+}

package/lib/errors.js

@@ -0,0 +1,28 @@
+export class SignalError extends Error {
+}
+export class UntrustedIdentityKeyError extends SignalError {
+    constructor(addr, identityKey) {
+        super();
+        this.name = 'UntrustedIdentityKeyError';
+        this.addr = addr;
+        this.identityKey = identityKey;
+    }
+}
+export class SessionError extends SignalError {
+    constructor(message) {
+        super(message);
+        this.name = 'SessionError';
+    }
+}
+export class MessageCounterError extends SessionError {
+    constructor(message) {
+        super(message);
+        this.name = 'MessageCounterError';
+    }
+}
+export class PreKeyError extends SessionError {
+    constructor(message) {
+        super(message);
+        this.name = 'PreKeyError';
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+export * as crypto from './crypto.js';
+export * as curve from './curve.js';
+export * as keyhelper from './keyhelper.js';
+export { ProtocolAddress } from './protocol-address.js';
+export { SessionBuilder } from './session-builder.js';
+export { assertValidDeviceKeyBundle } from './prekey-bundle-validator.js';
+export { SessionCipher } from './session-cipher.js';
+export { SessionRecord, SessionEntry } from './session-record.js';
+export { FingerprintGenerator } from './numeric-fingerprint.js';
+export { BaseKeyType } from './base-key-type.js';
+export { ChainType } from './chain-type.js';
+export { Direction } from './direction.js';
+export { MemorySignalStorage } from './memory-storage.js';
+export { setLogger, getLogger } from './logger.js';
+export type { SignalLogger } from './logger.js';
+export { wipeBuffer, wipeBuffers } from './util.js';
+export * from './errors.js';
+export type { KeyPair } from './curve.js';
+export type { SignalStorage, DeviceKeyBundle, IncomingPreKeyMessage, EncryptedMessage } from './types.js';
+export type { Chain, ChainKey, CurrentRatchet, IndexInfo, PendingPreKey, SerializedSessionEntry } from './session-record.js';

package/lib/index.js

@@ -0,0 +1,16 @@
+export * as crypto from './crypto.js';
+export * as curve from './curve.js';
+export * as keyhelper from './keyhelper.js';
+export { ProtocolAddress } from './protocol-address.js';
+export { SessionBuilder } from './session-builder.js';
+export { assertValidDeviceKeyBundle } from './prekey-bundle-validator.js';
+export { SessionCipher } from './session-cipher.js';
+export { SessionRecord, SessionEntry } from './session-record.js';
+export { FingerprintGenerator } from './numeric-fingerprint.js';
+export { BaseKeyType } from './base-key-type.js';
+export { ChainType } from './chain-type.js';
+export { Direction } from './direction.js';
+export { MemorySignalStorage } from './memory-storage.js';
+export { setLogger, getLogger } from './logger.js';
+export { wipeBuffer, wipeBuffers } from './util.js';
+export * from './errors.js';

package/lib/keyhelper.d.ts

@@ -0,0 +1,18 @@
+import * as curve from './curve.js';
+import type { KeyPair } from './curve.js';
+export interface SignedPreKey {
+    keyId: number;
+    keyPair: KeyPair;
+    signature: Buffer;
+    createdAt: number;
+}
+export interface PreKey {
+    keyId: number;
+    keyPair: KeyPair;
+}
+export declare const DEFAULT_SIGNED_PRE_KEY_MAX_AGE_MS: number;
+export declare function shouldRotateSignedPreKey(createdAt: number, maxAgeMs?: number): boolean;
+export declare const generateIdentityKeyPair: typeof curve.generateKeyPair;
+export declare function generateRegistrationId(): number;
+export declare function generateSignedPreKey(identityKeyPair: KeyPair, signedKeyId: number): SignedPreKey;
+export declare function generatePreKey(keyId: number): PreKey;

package/lib/keyhelper.js

@@ -0,0 +1,52 @@
+import * as nodeCrypto from 'crypto';
+import * as curve from './curve.js';
+function isNonNegativeInteger(n) {
+    return typeof n === 'number' && n % 1 === 0 && n >= 0;
+}
+export const DEFAULT_SIGNED_PRE_KEY_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+export function shouldRotateSignedPreKey(createdAt, maxAgeMs = DEFAULT_SIGNED_PRE_KEY_MAX_AGE_MS) {
+    if (!isNonNegativeInteger(createdAt)) {
+        throw new TypeError('Invalid argument for createdAt: ' + createdAt);
+    }
+    if (!isNonNegativeInteger(maxAgeMs)) {
+        throw new TypeError('Invalid argument for maxAgeMs: ' + maxAgeMs);
+    }
+    return Date.now() - createdAt >= maxAgeMs;
+}
+export const generateIdentityKeyPair = curve.generateKeyPair;
+export function generateRegistrationId() {
+    let registrationId;
+    do {
+        registrationId = nodeCrypto.randomBytes(2).readUInt16BE(0) & 0x3fff;
+    } while (registrationId === 0);
+    return registrationId;
+}
+export function generateSignedPreKey(identityKeyPair, signedKeyId) {
+    if (!(identityKeyPair.privKey instanceof Buffer) ||
+        identityKeyPair.privKey.byteLength !== 32 ||
+        !(identityKeyPair.pubKey instanceof Buffer) ||
+        identityKeyPair.pubKey.byteLength !== 33) {
+        throw new TypeError('Invalid argument for identityKeyPair');
+    }
+    if (!isNonNegativeInteger(signedKeyId)) {
+        throw new TypeError('Invalid argument for signedKeyId: ' + signedKeyId);
+    }
+    const keyPair = curve.generateKeyPair();
+    const sig = curve.calculateSignature(identityKeyPair.privKey, keyPair.pubKey);
+    return {
+        keyId: signedKeyId,
+        keyPair,
+        signature: sig,
+        createdAt: Date.now()
+    };
+}
+export function generatePreKey(keyId) {
+    if (!isNonNegativeInteger(keyId)) {
+        throw new TypeError('Invalid argument for keyId: ' + keyId);
+    }
+    const keyPair = curve.generateKeyPair();
+    return {
+        keyId,
+        keyPair
+    };
+}

package/lib/logger.d.ts

@@ -0,0 +1,6 @@
+export interface SignalLogger {
+    warn(message: string, meta?: unknown): void;
+    debug(message: string, meta?: unknown): void;
+}
+export declare function setLogger(logger: SignalLogger | null): void;
+export declare function getLogger(): SignalLogger;

package/lib/logger.js

@@ -0,0 +1,11 @@
+const noopLogger = {
+    warn() { },
+    debug() { }
+};
+let currentLogger = noopLogger;
+export function setLogger(logger) {
+    currentLogger = logger || noopLogger;
+}
+export function getLogger() {
+    return currentLogger;
+}

package/lib/memory-storage.d.ts

@@ -0,0 +1,25 @@
+import type { KeyPair } from './curve.js';
+import type { Direction } from './direction.js';
+import { SessionRecord } from './session-record.js';
+import type { SignalStorage } from './types.js';
+export declare class MemorySignalStorage implements SignalStorage {
+    private identityKeyPair;
+    private registrationId;
+    private sessions;
+    private preKeys;
+    private signedPreKeys;
+    private trustedIdentities;
+    constructor(identityKeyPair: KeyPair, registrationId: number);
+    loadSession(id: string): Promise<SessionRecord | undefined>;
+    storeSession(id: string, session: SessionRecord): Promise<void>;
+    isTrustedIdentity(identifier: string, identityKey: Buffer, _direction: Direction): Promise<boolean>;
+    saveIdentity(identifier: string, identityKey: Buffer): Promise<boolean>;
+    removeIdentity(identifier: string): Promise<void>;
+    loadPreKey(id?: number | string): Promise<KeyPair | undefined>;
+    removePreKey(id: number): Promise<void>;
+    loadSignedPreKey(id?: number | string): Promise<KeyPair | undefined>;
+    getOurRegistrationId(): Promise<number>;
+    getOurIdentity(): Promise<KeyPair>;
+    storePreKey(id: number, keyPair: KeyPair): void;
+    storeSignedPreKey(id: number, keyPair: KeyPair): void;
+}

package/lib/memory-storage.js

@@ -0,0 +1,68 @@
+import { timingSafeEqual } from 'crypto';
+import { SessionRecord } from './session-record.js';
+function safeEqual(a, b) {
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    return timingSafeEqual(a, b);
+}
+export class MemorySignalStorage {
+    constructor(identityKeyPair, registrationId) {
+        this.sessions = new Map();
+        this.preKeys = new Map();
+        this.signedPreKeys = new Map();
+        this.trustedIdentities = new Map();
+        this.identityKeyPair = identityKeyPair;
+        this.registrationId = registrationId;
+    }
+    async loadSession(id) {
+        return this.sessions.get(id);
+    }
+    async storeSession(id, session) {
+        this.sessions.set(id, session);
+    }
+    async isTrustedIdentity(identifier, identityKey, _direction) {
+        const existing = this.trustedIdentities.get(identifier);
+        if (!existing) {
+            this.trustedIdentities.set(identifier, identityKey);
+            return true;
+        }
+        return safeEqual(existing, identityKey);
+    }
+    async saveIdentity(identifier, identityKey) {
+        const existing = this.trustedIdentities.get(identifier);
+        this.trustedIdentities.set(identifier, identityKey);
+        return !existing || !safeEqual(existing, identityKey);
+    }
+    async removeIdentity(identifier) {
+        this.trustedIdentities.delete(identifier);
+        this.sessions.delete(identifier);
+    }
+    async loadPreKey(id) {
+        if (id === undefined) {
+            return undefined;
+        }
+        return this.preKeys.get(Number(id));
+    }
+    async removePreKey(id) {
+        this.preKeys.delete(id);
+    }
+    async loadSignedPreKey(id) {
+        if (id === undefined) {
+            return undefined;
+        }
+        return this.signedPreKeys.get(Number(id));
+    }
+    async getOurRegistrationId() {
+        return this.registrationId;
+    }
+    async getOurIdentity() {
+        return this.identityKeyPair;
+    }
+    storePreKey(id, keyPair) {
+        this.preKeys.set(id, keyPair);
+    }
+    storeSignedPreKey(id, keyPair) {
+        this.signedPreKeys.set(id, keyPair);
+    }
+}

package/lib/numeric-fingerprint.d.ts

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