@vanzxy/baileys 2.0.0

package/lib/Framework/MediaManager.js

@@ -0,0 +1,152 @@
+import { randomBytes } from 'crypto';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+// Vanz@Port (from @queenanya/baileys Framework, originally Baileys PR #2710
+// by LuferOS) --- media conversion helpers: image/video → WebP stickers
+// (with optional packname/author EXIF), audio → OGG Opus voice notes.
+//
+// Vanz@Fix vs upstream: original hard-`require()`'d `node-webpmux` and
+// pulled in `ffmpeg-static` (bundles a per-platform ffmpeg binary) alongside
+// `fluent-ffmpeg`. `fluent-ffmpeg` is already an optional peer dep in this
+// fork, lazy-loaded via the getFfmpeg() pattern established in
+// Utils/MessageBuilder.js (15-08-26) — reused verbatim here instead of
+// re-introducing a static import or a second ffmpeg-binary dependency.
+// `node-webpmux` is lazy-loaded the same way, and only when packname/author
+// metadata is actually requested.
+let _ffmpeg;
+const getFfmpeg = async () => {
+    if (_ffmpeg === undefined) {
+        _ffmpeg = await import('fluent-ffmpeg').then((m) => m.default ?? m).catch(() => null);
+    }
+    if (!_ffmpeg)
+        throw new Error('fluent-ffmpeg is required for sticker/voice-note conversion. Install it with: npm i fluent-ffmpeg');
+    return _ffmpeg;
+};
+
+let _webpmux;
+const getWebpmux = async () => {
+    if (_webpmux === undefined) {
+        _webpmux = await import('node-webpmux').then((m) => m.default ?? m).catch(() => null);
+    }
+    if (!_webpmux)
+        throw new Error('node-webpmux is required for sticker packname/author metadata. Install it with: npm i node-webpmux (conversion without metadata does not need this package)');
+    return _webpmux;
+};
+
+export class MediaManager {
+    /** Generate a temp file path with a given extension */
+    static getTempFile(ext) {
+        return path.join(os.tmpdir(), `baileys-fw-${randomBytes(8).toString('hex')}.${ext}`);
+    }
+
+    /**
+     * Convert image or video to a WebP sticker buffer.
+     * Applies packname/author EXIF metadata when provided (requires the
+     * optional `node-webpmux` peer dependency — only loaded if metadata is given).
+     */
+    static async convertToSticker(inputPathOrBuffer, metadata) {
+        const ffmpegLib = await getFfmpeg();
+        const tempInput = MediaManager.getTempFile('in');
+        const tempOutput = MediaManager.getTempFile('webp');
+        try {
+            if (Buffer.isBuffer(inputPathOrBuffer)) {
+                await fs.promises.writeFile(tempInput, inputPathOrBuffer);
+            }
+            else {
+                await fs.promises.copyFile(inputPathOrBuffer, tempInput);
+            }
+            await new Promise((resolve, reject) => {
+                ffmpegLib(tempInput)
+                    .outputOptions([
+                    '-vcodec', 'libwebp',
+                    '-vf', 'scale=512:512:force_original_aspect_ratio=decrease,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=white@0',
+                    '-loop', '0',
+                    '-preset', 'default',
+                    '-an', '-vsync', '0',
+                    '-t', '00:00:05'
+                ])
+                    .output(tempOutput)
+                    .on('end', () => resolve())
+                    .on('error', (err) => reject(err))
+                    .run();
+            });
+            const webpBuffer = await fs.promises.readFile(tempOutput);
+            if (metadata?.packname || metadata?.author) {
+                // EXIF header: fixed 22-byte TIFF/IFD preamble (magic + one IFD
+                // entry pointing at the WhatsApp tag 0x0741) followed by a
+                // little-endian payload length and a little-endian offset to
+                // where the payload begins (always 22, the header's own size).
+                const exifJson = JSON.stringify({
+                    'sticker-pack-id': `com.vanzxy.sticker.${randomBytes(4).toString('hex')}`,
+                    'sticker-pack-name': metadata.packname || '',
+                    'sticker-pack-publisher': metadata.author || '',
+                    emojis: ['🤖']
+                });
+                const exifBytes = Buffer.from(exifJson, 'utf8');
+                const exifHeader = Buffer.from([
+                    0x49, 0x49, 0x2a, 0x00, // TIFF byte order (little-endian) + magic number
+                    0x08, 0x00, 0x00, 0x00, // offset to first IFD
+                    0x01, 0x00, // number of IFD entries
+                    0x41, 0x57, 0x07, 0x00, // tag 0x0741 (WhatsApp), type 0x0007 (undefined)
+                    0x00, 0x00, 0x00, 0x00, // payload length placeholder — filled below
+                    0x16, 0x00, 0x00, 0x00 // offset to payload data (fixed: 22 = header size)
+                ]);
+                exifHeader.writeUInt32LE(exifBytes.length, 14);
+                const fullExif = Buffer.concat([exifHeader, exifBytes]);
+                const webpmux = await getWebpmux();
+                const img = new webpmux.Image();
+                await img.load(webpBuffer);
+                img.exif = fullExif;
+                return await img.save(null);
+            }
+            return webpBuffer;
+        }
+        finally {
+            await fs.promises.unlink(tempInput).catch(() => { });
+            await fs.promises.unlink(tempOutput).catch(() => { });
+        }
+    }
+
+    /**
+     * Convert audio to OGG Opus voice note format.
+     * Mono, 16kHz, VOIP application mode — required by WA for PTT playback.
+     */
+    static async convertToVoiceNote(inputPathOrBuffer) {
+        const ffmpegLib = await getFfmpeg();
+        const tempInput = MediaManager.getTempFile('in');
+        const tempOutput = MediaManager.getTempFile('ogg');
+        try {
+            if (Buffer.isBuffer(inputPathOrBuffer)) {
+                await fs.promises.writeFile(tempInput, inputPathOrBuffer);
+            }
+            else {
+                await fs.promises.copyFile(inputPathOrBuffer, tempInput);
+            }
+            await new Promise((resolve, reject) => {
+                ffmpegLib(tempInput)
+                    .inputOptions(['-y'])
+                    .outputOptions([
+                    '-c:a', 'libopus',
+                    '-ac', '1', // mono channel (required by WA)
+                    '-ar', '16000', // 16kHz sample rate
+                    '-application', 'voip',
+                    '-b:a', '32k',
+                    '-compression_level', '10',
+                    '-vbr', 'on'
+                ])
+                    .format('ogg')
+                    .output(tempOutput)
+                    .on('end', () => resolve())
+                    .on('error', (err) => reject(err))
+                    .run();
+            });
+            return await fs.promises.readFile(tempOutput);
+        }
+        finally {
+            await fs.promises.unlink(tempInput).catch(() => { });
+            await fs.promises.unlink(tempOutput).catch(() => { });
+        }
+    }
+}

package/lib/Framework/SessionManager.js

@@ -0,0 +1,34 @@
+// Vanz@Port (from @queenanya/baileys Framework, originally Baileys PR #2710
+// by LuferOS) --- per-JID session CRUD backed by SQLiteStore. Unchanged logic
+// from upstream; only the SQLiteStore instance it wraps is now created via
+// an async factory (see Store/SQLiteStore.js).
+export class SessionManager {
+    constructor(store) {
+        this.store = store;
+    }
+
+    key(jid) {
+        return `session_${jid}`;
+    }
+
+    get(jid) {
+        return this.store.get(this.key(jid));
+    }
+
+    set(jid, data) {
+        this.store.set(this.key(jid), data);
+    }
+
+    update(jid, updater) {
+        const prev = this.get(jid);
+        this.set(jid, updater(prev));
+    }
+
+    delete(jid) {
+        this.store.del(this.key(jid));
+    }
+
+    has(jid) {
+        return this.get(jid) !== undefined;
+    }
+}

package/lib/Framework/StatsManager.js

@@ -0,0 +1,120 @@
+import { Boom } from '@hapi/boom';
+import { jidNormalizedUser } from '../WABinary/index.js';
+
+// Vanz@Port (from @queenanya/baileys Framework, originally Baileys PR #2710
+// by LuferOS) --- group activity tracking: message counts, sticker counts,
+// leaderboards, ghost (inactive member) detection.
+//
+// Kept from upstream's P0-P3 pass:
+//  - all participant JIDs normalized via jidNormalizedUser() before storing/
+//    querying, so PN/LID/device (:0, :42) variants resolve to the same row
+//  - getTopUsers/getTopStickers guard limit to a positive integer
+//  - getGhosts throws Boom(503) instead of a bare Error when the socket
+//    isn't connected, so callers can branch on statusCode
+//
+// Vanz@Fix vs upstream: same issue as SQLiteStore — `better-sqlite3` was a
+// hard top-level import. Reused the lazy loadBetterSqlite3() pattern and
+// moved construction behind an async `StatsManager.create()` factory.
+async function loadBetterSqlite3() {
+    try {
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for the Framework StatsManager. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+
+export class StatsManager {
+    constructor(db, groupMetaFn) {
+        this.db = db;
+        this.groupMetaFn = groupMetaFn;
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS group_stats (
+				group_jid    TEXT NOT NULL,
+				user_jid     TEXT NOT NULL,
+				msg_count    INTEGER NOT NULL DEFAULT 0,
+				sticker_count INTEGER NOT NULL DEFAULT 0,
+				last_active  INTEGER NOT NULL,
+				PRIMARY KEY (group_jid, user_jid)
+			)
+		`);
+        this.insertStmt = this.db.prepare(`
+			INSERT INTO group_stats (group_jid, user_jid, msg_count, sticker_count, last_active)
+			VALUES (?, ?, ?, ?, ?)
+			ON CONFLICT(group_jid, user_jid) DO UPDATE SET
+				msg_count     = msg_count + excluded.msg_count,
+				sticker_count = sticker_count + excluded.sticker_count,
+				last_active   = excluded.last_active
+		`);
+        this.getStatsStmt = this.db.prepare('SELECT user_jid, msg_count, sticker_count, last_active FROM group_stats WHERE group_jid = ?');
+        this.getTopMsgStmt = (limit) => this.db.prepare(`SELECT user_jid AS jid, msg_count AS count FROM group_stats WHERE group_jid = ? ORDER BY msg_count DESC LIMIT ${limit}`);
+        this.getTopStickerStmt = (limit) => this.db.prepare(`SELECT user_jid AS jid, sticker_count AS count FROM group_stats WHERE group_jid = ? ORDER BY sticker_count DESC LIMIT ${limit}`);
+    }
+
+    /** Vanz@Port: replaces the old synchronous `new StatsManager(dbPath, groupMetaFn)`. */
+    static async create(dbPath, groupMetaFn) {
+        const Database = await loadBetterSqlite3();
+        return new StatsManager(new Database(dbPath), groupMetaFn);
+    }
+
+    /** Record a message observation for stats. Normalizes both JIDs before storing. */
+    observeMessage(groupJid, userJid, isSticker) {
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        const normalizedUserJid = jidNormalizedUser(userJid);
+        const msgCount = 1;
+        const stickerCount = isSticker ? 1 : 0;
+        const now = Date.now();
+        this.insertStmt.run(normalizedGroupJid, normalizedUserJid, msgCount, stickerCount, now);
+    }
+
+    /** Top message senders for a group. */
+    getTopUsers(groupJid, limit = 10) {
+        const safeLimit = Math.max(1, Math.floor(limit));
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        return this.getTopMsgStmt(safeLimit).all(normalizedGroupJid);
+    }
+
+    /** Top sticker senders for a group. */
+    getTopStickers(groupJid, limit = 10) {
+        const safeLimit = Math.max(1, Math.floor(limit));
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        return this.getTopStickerStmt(safeLimit).all(normalizedGroupJid);
+    }
+
+    /** Detect inactive members ("ghosts") in a group. */
+    async getGhosts(groupJid, socketConnected, inactiveDays = 30) {
+        if (!socketConnected) {
+            throw new Boom('Socket not connected — cannot fetch group metadata for ghost detection', {
+                statusCode: 503
+            });
+        }
+        const normalizedGroupJid = jidNormalizedUser(groupJid);
+        const cutoff = Date.now() - inactiveDays * 24 * 60 * 60 * 1000;
+        const rows = this.getStatsStmt.all(normalizedGroupJid);
+        const statsMap = new Map();
+        for (const row of rows) {
+            statsMap.set(jidNormalizedUser(row.user_jid), row.last_active);
+        }
+        const groupMeta = await this.groupMetaFn(groupJid);
+        return groupMeta.participants
+            .map(p => {
+            const normalizedJid = jidNormalizedUser(p.id);
+            const lastActive = statsMap.get(normalizedJid);
+            if (!lastActive) {
+                return { jid: normalizedJid, isTotalGhost: true };
+            }
+            if (lastActive < cutoff) {
+                return { jid: normalizedJid, isTotalGhost: false, lastActive };
+            }
+            return null;
+        })
+            .filter((g) => g !== null);
+    }
+
+    close() {
+        this.db.close();
+    }
+}

package/lib/Framework/Store/SQLiteStore.js

@@ -0,0 +1,74 @@
+// Vanz@Port (from @queenanya/baileys Framework, originally Baileys PR #2710
+// by LuferOS) --- generic key-value store backed by better-sqlite3. Used by
+// SessionManager to persist per-JID session state to disk instead of RAM.
+//
+// Vanz@Fix vs upstream: `better-sqlite3` was a hard top-level `import`, which
+// would crash the whole Framework import at module-load time for anyone who
+// hasn't installed it (it's an optional peer dep in this fork, same as
+// use-sqlite-auth-state). Switched to the lazy `loadBetterSqlite3()` loader
+// already used by Utils/use-sqlite-auth-state.js, and moved construction
+// behind an async `SQLiteStore.create()` factory since the loader is async.
+async function loadBetterSqlite3() {
+    try {
+        const mod = (await import('better-sqlite3'));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for the Framework SQLiteStore. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+
+export class SQLiteStore {
+    constructor(db) {
+        this.db = db;
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS kv_store (
+				key   TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			)
+		`);
+        this.getStmt = this.db.prepare('SELECT value FROM kv_store WHERE key = ?');
+        this.setStmt = this.db.prepare('INSERT INTO kv_store (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value');
+        this.delStmt = this.db.prepare('DELETE FROM kv_store WHERE key = ?');
+    }
+
+    /** Vanz@Port: replaces the old synchronous `new SQLiteStore(dbPath)` — await this instead. */
+    static async create(dbPath) {
+        const Database = await loadBetterSqlite3();
+        return new SQLiteStore(new Database(dbPath));
+    }
+
+    get(key) {
+        const row = this.getStmt.get(key);
+        if (!row)
+            return undefined;
+        try {
+            return JSON.parse(row.value);
+        }
+        catch {
+            // Fallback for legacy non-JSON rows (migration safety)
+            return row.value;
+        }
+    }
+
+    set(key, value) {
+        // guard undefined/null — delegate to del so callers don't need to check
+        if (value === undefined || value === null) {
+            this.del(key);
+            return;
+        }
+        // always JSON.stringify — raw string storage breaks round-trip for
+        // values that are valid JSON (numbers, booleans, JSON objects serialized as strings)
+        this.setStmt.run(key, JSON.stringify(value));
+    }
+
+    del(key) {
+        this.delStmt.run(key);
+    }
+
+    close() {
+        this.db.close();
+    }
+}

package/lib/Framework/index.js

@@ -0,0 +1,11 @@
+// Vanz@Port --- Enterprise Bot Framework exports.
+// Source: WhiskeySockets/Baileys PR #2710 (LuferOS), via @queenanya/baileys.
+// Adapted for this fork: SQLiteStore/StatsManager are lazy-loaded (see
+// Store/SQLiteStore.js and StatsManager.js), MediaManager spawns the system
+// `ffmpeg` binary instead of bundling fluent-ffmpeg/ffmpeg-static.
+export { Bot } from './Bot.js';
+export { Context } from './Context.js';
+export { MediaManager } from './MediaManager.js';
+export { SessionManager } from './SessionManager.js';
+export { StatsManager } from './StatsManager.js';
+export { SQLiteStore } from './Store/SQLiteStore.js';

package/lib/Signal/Group/ciphertext-message.d.ts

@@ -0,0 +1,9 @@
+export class CiphertextMessage {
+    UNSUPPORTED_VERSION: number;
+    CURRENT_VERSION: number;
+    WHISPER_TYPE: number;
+    PREKEY_TYPE: number;
+    SENDERKEY_TYPE: number;
+    SENDERKEY_DISTRIBUTION_TYPE: number;
+    ENCRYPTED_MESSAGE_OVERHEAD: number;
+}

package/lib/Signal/Group/ciphertext-message.js

@@ -0,0 +1,12 @@
+export class CiphertextMessage {
+    constructor() {
+        this.UNSUPPORTED_VERSION = 1;
+        this.CURRENT_VERSION = 3;
+        this.WHISPER_TYPE = 2;
+        this.PREKEY_TYPE = 3;
+        this.SENDERKEY_TYPE = 4;
+        this.SENDERKEY_DISTRIBUTION_TYPE = 5;
+        this.ENCRYPTED_MESSAGE_OVERHEAD = 53;
+    }
+}
+//# sourceMappingURL=ciphertext-message.js.map

package/lib/Signal/Group/group-session-builder.d.ts

@@ -0,0 +1,7 @@
+export class GroupSessionBuilder {
+    constructor(senderKeyStore: any);
+    senderKeyStore: any;
+    process(senderKeyName: any, senderKeyDistributionMessage: any): Promise<void>;
+    create(senderKeyName: any): Promise<SenderKeyDistributionMessage>;
+}
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';

package/lib/Signal/Group/group-session-builder.js

@@ -0,0 +1,30 @@
+import * as keyhelper from './keyhelper.js';
+import { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+export class GroupSessionBuilder {
+    constructor(senderKeyStore) {
+        this.senderKeyStore = senderKeyStore;
+    }
+    async process(senderKeyName, senderKeyDistributionMessage) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        senderKeyRecord.addSenderKeyState(senderKeyDistributionMessage.getId(), senderKeyDistributionMessage.getIteration(), senderKeyDistributionMessage.getChainKey(), senderKeyDistributionMessage.getSignatureKey());
+        await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+    }
+    async create(senderKeyName) {
+        const senderKeyRecord = await this.senderKeyStore.loadSenderKey(senderKeyName);
+        if (senderKeyRecord.isEmpty()) {
+            const keyId = keyhelper.generateSenderKeyId();
+            const senderKey = keyhelper.generateSenderKey();
+            const signingKey = keyhelper.generateSenderSigningKey();
+            senderKeyRecord.setSenderKeyState(keyId, 0, senderKey, signingKey);
+            await this.senderKeyStore.storeSenderKey(senderKeyName, senderKeyRecord);
+        }
+        const state = senderKeyRecord.getSenderKeyState();
+        if (!state) {
+            throw new Error('No session state available');
+        }
+        return new SenderKeyDistributionMessage(state.getKeyId(), state.getSenderChainKey().getIteration(), state.getSenderChainKey().getSeed(), state.getSigningKeyPublic());
+    }
+}
+//# sourceMappingURL=group-session-builder.js.map

package/lib/Signal/Group/group_cipher.d.ts

@@ -0,0 +1,10 @@
+export class GroupCipher {
+    constructor(senderKeyStore: any, senderKeyName: any);
+    senderKeyStore: any;
+    senderKeyName: any;
+    encrypt(paddedPlaintext: any): Promise<any>;
+    decrypt(senderKeyMessageBytes: any): Promise<any>;
+    getSenderKey(senderKeyState: any, iteration: any): any;
+    getPlainText(iv: any, key: any, ciphertext: any): Promise<any>;
+    getCipherText(iv: any, key: any, plaintext: any): Promise<any>;
+}

package/lib/Signal/Group/group_cipher.js

@@ -0,0 +1,82 @@
+import { decrypt, encrypt } from 'libsignal/src/crypto.js';
+import { SenderKeyMessage } from './sender-key-message.js';
+import { SenderKeyName } from './sender-key-name.js';
+import { SenderKeyRecord } from './sender-key-record.js';
+import { SenderKeyState } from './sender-key-state.js';
+export class GroupCipher {
+    constructor(senderKeyStore, senderKeyName) {
+        this.senderKeyStore = senderKeyStore;
+        this.senderKeyName = senderKeyName;
+    }
+    async encrypt(paddedPlaintext) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for encryption');
+        }
+        const senderKeyState = record.getSenderKeyState();
+        if (!senderKeyState) {
+            throw new Error('No session to encrypt message');
+        }
+        const iteration = senderKeyState.getSenderChainKey().getIteration();
+        const senderKey = this.getSenderKey(senderKeyState, iteration === 0 ? 0 : iteration + 1);
+        const ciphertext = await this.getCipherText(senderKey.getIv(), senderKey.getCipherKey(), paddedPlaintext);
+        const senderKeyMessage = new SenderKeyMessage(senderKeyState.getKeyId(), senderKey.getIteration(), ciphertext, senderKeyState.getSigningKeyPrivate());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return senderKeyMessage.serialize();
+    }
+    async decrypt(senderKeyMessageBytes) {
+        const record = await this.senderKeyStore.loadSenderKey(this.senderKeyName);
+        if (!record) {
+            throw new Error('No SenderKeyRecord found for decryption');
+        }
+        const senderKeyMessage = new SenderKeyMessage(null, null, null, null, senderKeyMessageBytes);
+        const senderKeyState = record.getSenderKeyState(senderKeyMessage.getKeyId());
+        if (!senderKeyState) {
+            throw new Error('No session found to decrypt message');
+        }
+        senderKeyMessage.verifySignature(senderKeyState.getSigningKeyPublic());
+        const senderKey = this.getSenderKey(senderKeyState, senderKeyMessage.getIteration());
+        const plaintext = await this.getPlainText(senderKey.getIv(), senderKey.getCipherKey(), senderKeyMessage.getCipherText());
+        await this.senderKeyStore.storeSenderKey(this.senderKeyName, record);
+        return plaintext;
+    }
+    getSenderKey(senderKeyState, iteration) {
+        let senderChainKey = senderKeyState.getSenderChainKey();
+        if (senderChainKey.getIteration() > iteration) {
+            if (senderKeyState.hasSenderMessageKey(iteration)) {
+                const messageKey = senderKeyState.removeSenderMessageKey(iteration);
+                if (!messageKey) {
+                    throw new Error('No sender message key found for iteration');
+                }
+                return messageKey;
+            }
+            throw new Error(`Received message with old counter: ${senderChainKey.getIteration()}, ${iteration}`);
+        }
+        if (iteration - senderChainKey.getIteration() > 2000) {
+            throw new Error('Over 2000 messages into the future!');
+        }
+        while (senderChainKey.getIteration() < iteration) {
+            senderKeyState.addSenderMessageKey(senderChainKey.getSenderMessageKey());
+            senderChainKey = senderChainKey.getNext();
+        }
+        senderKeyState.setSenderChainKey(senderChainKey.getNext());
+        return senderChainKey.getSenderMessageKey();
+    }
+    async getPlainText(iv, key, ciphertext) {
+        try {
+            return decrypt(key, ciphertext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+    async getCipherText(iv, key, plaintext) {
+        try {
+            return encrypt(key, plaintext, iv);
+        }
+        catch (e) {
+            throw new Error('InvalidMessageException');
+        }
+    }
+}
+//# sourceMappingURL=group_cipher.js.map

package/lib/Signal/Group/index.d.ts

@@ -0,0 +1,11 @@
+export { GroupSessionBuilder } from "./group-session-builder.js";
+export { SenderKeyDistributionMessage } from "./sender-key-distribution-message.js";
+export { SenderKeyRecord } from "./sender-key-record.js";
+export { SenderKeyName } from "./sender-key-name.js";
+export { GroupCipher } from "./group_cipher.js";
+export { SenderKeyState } from "./sender-key-state.js";
+export { SenderKeyMessage } from "./sender-key-message.js";
+export { SenderMessageKey } from "./sender-message-key.js";
+export { SenderChainKey } from "./sender-chain-key.js";
+export { CiphertextMessage } from "./ciphertext-message.js";
+export * as keyhelper from "./keyhelper.js";

package/lib/Signal/Group/index.js

@@ -0,0 +1,12 @@
+export { GroupSessionBuilder } from './group-session-builder.js';
+export { SenderKeyDistributionMessage } from './sender-key-distribution-message.js';
+export { SenderKeyRecord } from './sender-key-record.js';
+export { SenderKeyName } from './sender-key-name.js';
+export { GroupCipher } from './group_cipher.js';
+export { SenderKeyState } from './sender-key-state.js';
+export { SenderKeyMessage } from './sender-key-message.js';
+export { SenderMessageKey } from './sender-message-key.js';
+export { SenderChainKey } from './sender-chain-key.js';
+export { CiphertextMessage } from './ciphertext-message.js';
+export * as keyhelper from './keyhelper.js';
+//# sourceMappingURL=index.js.map

package/lib/Signal/Group/keyhelper.d.ts

@@ -0,0 +1,6 @@
+export function generateSenderKey(): any;
+export function generateSenderKeyId(): any;
+export function generateSenderSigningKey(key: any): {
+    public: any;
+    private: any;
+};

package/lib/Signal/Group/keyhelper.js

@@ -0,0 +1,18 @@
+import * as nodeCrypto from 'crypto';
+import { generateKeyPair } from 'libsignal/src/curve.js';
+export function generateSenderKey() {
+    return nodeCrypto.randomBytes(32);
+}
+export function generateSenderKeyId() {
+    return nodeCrypto.randomInt(2147483647);
+}
+export function generateSenderSigningKey(key) {
+    if (!key) {
+        key = generateKeyPair();
+    }
+    return {
+        public: Buffer.from(key.pubKey),
+        private: Buffer.from(key.privKey)
+    };
+}
+//# sourceMappingURL=keyhelper.js.map

package/lib/Signal/Group/sender-chain-key.d.ts

@@ -0,0 +1,13 @@
+export class SenderChainKey {
+    constructor(iteration: any, chainKey: any);
+    MESSAGE_KEY_SEED: any;
+    CHAIN_KEY_SEED: any;
+    iteration: any;
+    chainKey: any;
+    getIteration(): any;
+    getSenderMessageKey(): SenderMessageKey;
+    getNext(): SenderChainKey;
+    getSeed(): any;
+    getDerivative(seed: any, key: any): any;
+}
+import { SenderMessageKey } from './sender-message-key.js';

package/lib/Signal/Group/sender-chain-key.js

@@ -0,0 +1,26 @@
+import { calculateMAC } from 'libsignal/src/crypto.js';
+import { SenderMessageKey } from './sender-message-key.js';
+export class SenderChainKey {
+    constructor(iteration, chainKey) {
+        this.MESSAGE_KEY_SEED = Buffer.from([0x01]);
+        this.CHAIN_KEY_SEED = Buffer.from([0x02]);
+        this.iteration = iteration;
+        this.chainKey = Buffer.from(chainKey);
+    }
+    getIteration() {
+        return this.iteration;
+    }
+    getSenderMessageKey() {
+        return new SenderMessageKey(this.iteration, this.getDerivative(this.MESSAGE_KEY_SEED, this.chainKey));
+    }
+    getNext() {
+        return new SenderChainKey(this.iteration + 1, this.getDerivative(this.CHAIN_KEY_SEED, this.chainKey));
+    }
+    getSeed() {
+        return this.chainKey;
+    }
+    getDerivative(seed, key) {
+        return calculateMAC(key, seed);
+    }
+}
+//# sourceMappingURL=sender-chain-key.js.map

package/lib/Signal/Group/sender-key-distribution-message.d.ts

@@ -0,0 +1,16 @@
+export class SenderKeyDistributionMessage extends CiphertextMessage {
+    constructor(id: any, iteration: any, chainKey: any, signatureKey: any, serialized: any);
+    serialized: any;
+    id: any;
+    iteration: any;
+    chainKey: any;
+    signatureKey: any;
+    intsToByteHighAndLow(highValue: any, lowValue: any): number;
+    serialize(): any;
+    getType(): number;
+    getIteration(): any;
+    getChainKey(): any;
+    getSignatureKey(): any;
+    getId(): any;
+}
+import { CiphertextMessage } from './ciphertext-message.js';