@vanzxy/baileys 2.0.0

package/lib/Utils/anti-delete.d.ts

@@ -0,0 +1,74 @@
+import type { WAMessage, WAMessageKey } from '../Types/index.js';
+export interface MessageStoreOptions {
+    maxMessagesPerChat?: number;
+    ttl?: number;
+    cleanupInterval?: number;
+}
+export interface StoredMessage {
+    message: WAMessage;
+    storedAt: number;
+    isDeleted: boolean;
+    deletedAt?: number;
+    deletedBy?: string;
+}
+export interface DeletedMessageInfo {
+    originalMessage: WAMessage;
+    key: WAMessageKey;
+    deletedAt: number;
+    deletedBy?: string;
+    isRevokedBySender: boolean;
+}
+export declare class MessageStore {
+    private store;
+    private deletedMessages;
+    private cleanupTimer;
+    private options;
+    constructor(options?: MessageStoreOptions);
+    stopCleanup(): void;
+    storeMessage(message: WAMessage): void;
+    storeMessages(messages: WAMessage[]): void;
+    getMessage(key: WAMessageKey): StoredMessage | undefined;
+    getOriginalMessage(key: WAMessageKey): WAMessage | undefined;
+    markAsDeleted(key: WAMessageKey, deletedBy?: string): DeletedMessageInfo | null;
+    getDeletedMessage(key: WAMessageKey): DeletedMessageInfo | undefined;
+    getAllDeletedMessages(): DeletedMessageInfo[];
+    getDeletedMessagesByChat(chatId: string): DeletedMessageInfo[];
+    getChatMessages(chatId: string): WAMessage[];
+    getChatIds(): string[];
+    getStats(): {
+        totalChats: number;
+        totalMessages: number;
+        totalDeleted: number;
+    };
+    clear(): void;
+    clearChat(chatId: string): void;
+    getAllMessages(): Record<string, WAMessage[]>;
+}
+export declare const isDeleteMessage: (message: WAMessage) => boolean;
+export declare const getDeletedMessageKey: (message: WAMessage) => WAMessageKey | null;
+export declare const createAntiDeleteHandler: (store: MessageStore, onDelete?: (info: DeletedMessageInfo) => void) => (updates: Array<{
+    key: WAMessageKey;
+    update: Partial<WAMessage>;
+}>) => DeletedMessageInfo[];
+export declare const createAntiDeleteUpsertHandler: (store: MessageStore, onDelete?: (info: DeletedMessageInfo) => void) => ({ messages }: {
+    messages: WAMessage[];
+}) => DeletedMessageInfo[];
+export declare const createMessageStoreHandler: (store: MessageStore) => ({ messages }: {
+    messages: WAMessage[];
+}) => void;
+declare const _default: {
+    MessageStore: typeof MessageStore;
+    isDeleteMessage: (message: WAMessage) => boolean;
+    getDeletedMessageKey: (message: WAMessage) => WAMessageKey | null;
+    createAntiDeleteHandler: (store: MessageStore, onDelete?: (info: DeletedMessageInfo) => void) => (updates: Array<{
+        key: WAMessageKey;
+        update: Partial<WAMessage>;
+    }>) => DeletedMessageInfo[];
+    createAntiDeleteUpsertHandler: (store: MessageStore, onDelete?: (info: DeletedMessageInfo) => void) => ({ messages }: {
+        messages: WAMessage[];
+    }) => DeletedMessageInfo[];
+    createMessageStoreHandler: (store: MessageStore) => ({ messages }: {
+        messages: WAMessage[];
+    }) => void;
+};
+export default _default;

package/lib/Utils/anti-delete.js

@@ -0,0 +1,222 @@
+// Vanz@Add --- ported from Bail-master addons/anti-delete.ts (adapted to lib/ CJS-free ESM
+// runtime style used throughout this fork; type-only annotations dropped, behavior unchanged).
+import { proto } from '../../WAProto/index.js';
+// ── MessageStore ───────────────────────────────────────────────────────────
+/**
+ * In-memory, TTL-bounded store of recently seen messages, used to recover the
+ * original content of a message after WhatsApp delivers a REVOKE (delete-for-everyone)
+ * protocol message, which itself carries no content — only a reference key.
+ */
+export class MessageStore {
+    store = new Map();
+    deletedMessages = new Map();
+    cleanupTimer = null;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            maxMessagesPerChat: options.maxMessagesPerChat ?? 1000,
+            ttl: options.ttl ?? 24 * 60 * 60 * 1000,
+            cleanupInterval: options.cleanupInterval ?? 60 * 60 * 1000
+        };
+        this.startCleanup();
+    }
+    startCleanup() {
+        this.cleanupTimer = setInterval(() => this.cleanup(), this.options.cleanupInterval);
+        this.cleanupTimer?.unref?.();
+    }
+    stopCleanup() {
+        if (this.cleanupTimer)
+            clearInterval(this.cleanupTimer);
+    }
+    cleanup() {
+        const cutoff = Date.now() - this.options.ttl;
+        for (const [chatId, messages] of this.store) {
+            for (const [msgId, stored] of messages) {
+                if (stored.storedAt < cutoff)
+                    messages.delete(msgId);
+            }
+            if (messages.size === 0)
+                this.store.delete(chatId);
+        }
+        for (const [key, info] of this.deletedMessages) {
+            if (info.deletedAt < cutoff)
+                this.deletedMessages.delete(key);
+        }
+    }
+    getKey(key) {
+        return `${key.remoteJid}:${key.id}`;
+    }
+    storeMessage(message) {
+        const chatId = message.key.remoteJid;
+        if (!chatId || !message.key.id)
+            return;
+        let chatMessages = this.store.get(chatId);
+        if (!chatMessages) {
+            chatMessages = new Map();
+            this.store.set(chatId, chatMessages);
+        }
+        if (chatMessages.size >= this.options.maxMessagesPerChat) {
+            const oldestKey = chatMessages.keys().next().value;
+            if (oldestKey)
+                chatMessages.delete(oldestKey);
+        }
+        chatMessages.set(message.key.id, { message, storedAt: Date.now(), isDeleted: false });
+    }
+    storeMessages(messages) {
+        for (const msg of messages)
+            this.storeMessage(msg);
+    }
+    getMessage(key) {
+        return this.store.get(key.remoteJid)?.get(key.id);
+    }
+    getOriginalMessage(key) {
+        return this.getMessage(key)?.message;
+    }
+    markAsDeleted(key, deletedBy) {
+        const stored = this.getMessage(key);
+        if (!stored)
+            return null;
+        const now = Date.now();
+        stored.isDeleted = true;
+        stored.deletedAt = now;
+        stored.deletedBy = deletedBy;
+        // Vanz@Fix (bug 66): the old check (`deletedBy === stored.message.key.participant`)
+        // only works in groups, where `participant` identifies who sent/revoked a message.
+        // In a private chat `key.participant` is always undefined (it's a group-only field),
+        // while `deletedBy` there falls back to `remoteJid` — so the comparison could never
+        // match and isRevokedBySender was always false for every DM, even though
+        // delete-for-everyone in a DM can only be done by the original sender. Treat a
+        // missing `participant` (i.e. not a group message) as "revoked by sender" by definition.
+        const isGroupMessage = !!stored.message.key.participant;
+        const info = {
+            originalMessage: stored.message,
+            key,
+            deletedAt: now,
+            deletedBy,
+            isRevokedBySender: !deletedBy || !isGroupMessage || deletedBy === stored.message.key.participant
+        };
+        this.deletedMessages.set(this.getKey(key), info);
+        return info;
+    }
+    getDeletedMessage(key) {
+        return this.deletedMessages.get(this.getKey(key));
+    }
+    getAllDeletedMessages() {
+        return Array.from(this.deletedMessages.values());
+    }
+    getDeletedMessagesByChat(chatId) {
+        return Array.from(this.deletedMessages.values()).filter((i) => i.key.remoteJid === chatId);
+    }
+    getChatMessages(chatId) {
+        return Array.from(this.store.get(chatId)?.values() ?? []).map((s) => s.message);
+    }
+    getChatIds() {
+        return Array.from(this.store.keys());
+    }
+    getStats() {
+        let totalMessages = 0;
+        for (const messages of this.store.values())
+            totalMessages += messages.size;
+        return { totalChats: this.store.size, totalMessages, totalDeleted: this.deletedMessages.size };
+    }
+    clear() {
+        this.store.clear();
+        this.deletedMessages.clear();
+    }
+    clearChat(chatId) {
+        this.store.delete(chatId);
+    }
+    getAllMessages() {
+        const all = {};
+        for (const [chatId, messages] of this.store) {
+            all[chatId] = Array.from(messages.values()).map((s) => s.message);
+        }
+        return all;
+    }
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+export const isDeleteMessage = (message) => {
+    return message.message?.protocolMessage?.type === proto.Message.ProtocolMessage.Type.REVOKE;
+};
+export const getDeletedMessageKey = (message) => {
+    const protoMsg = message.message?.protocolMessage;
+    if (protoMsg?.type !== proto.Message.ProtocolMessage.Type.REVOKE)
+        return null;
+    return protoMsg.key ?? null;
+};
+/**
+ * Wire this into `sock.ev.on('messages.update', ...)`. Fires `onDelete` for
+ * every update in the batch whose stub type is REVOKE, using `store` to look
+ * up the original content that WhatsApp's own update payload omits.
+ */
+export const createAntiDeleteHandler = (store, onDelete) => {
+    return (updates) => {
+        const deletedMessages = [];
+        for (const { key, update } of updates) {
+            if (update.messageStubType === proto.WebMessageInfo.StubType.REVOKE) {
+                const info = store.markAsDeleted(key, update.messageStubParameters?.[0]);
+                if (info) {
+                    deletedMessages.push(info);
+                    onDelete?.(info);
+                }
+            }
+        }
+        return deletedMessages;
+    };
+};
+/**
+ * Vanz@Fix (bug 58): `createAntiDeleteHandler` above only listens on
+ * `messages.update` with `messageStubType === REVOKE`. In practice, most
+ * delete-for-everyone events actually arrive as a *new* message on
+ * `messages.upsert` carrying a `protocolMessage` of type REVOKE (the
+ * `isDeleteMessage`/`getDeletedMessageKey` helpers above existed for this but
+ * were never wired to anything). Wire this into `sock.ev.on('messages.upsert', ...)`
+ * alongside `createMessageStoreHandler` to actually catch those.
+ */
+export const createAntiDeleteUpsertHandler = (store, onDelete) => {
+    return ({ messages }) => {
+        const deletedMessages = [];
+        for (const message of messages) {
+            if (!isDeleteMessage(message))
+                continue;
+            const key = getDeletedMessageKey(message);
+            if (!key)
+                continue;
+            const deletedBy = message.key.participant || message.key.remoteJid;
+            const info = store.markAsDeleted(key, deletedBy);
+            if (info) {
+                deletedMessages.push(info);
+                onDelete?.(info);
+            }
+        }
+        return deletedMessages;
+    };
+};
+/**
+ * Wire this into `sock.ev.on('messages.upsert', ...)` to keep `store` populated.
+ * Skips protocol/sender-key-distribution messages, which carry no user content.
+ */
+export const createMessageStoreHandler = (store) => {
+    return ({ messages }) => {
+        const regular = messages.filter((msg) => {
+            const c = msg.message;
+            if (!c)
+                return false;
+            if (c.protocolMessage)
+                return false;
+            if (c.senderKeyDistributionMessage)
+                return false;
+            return true;
+        });
+        store.storeMessages(regular);
+    };
+};
+export default {
+    MessageStore,
+    isDeleteMessage,
+    getDeletedMessageKey,
+    createAntiDeleteHandler,
+    createAntiDeleteUpsertHandler,
+    createMessageStoreHandler
+};
+//# sourceMappingURL=anti-delete.js.map

package/lib/Utils/auth-utils.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(store: any, logger: any, _cache: any): {
+    get(type: any, ids: any): Promise<any>;
+    set(data: any): Promise<any>;
+    clear(): Promise<void>;
+};
+export function addTransactionCapability(state: any, logger: any, { maxCommitRetries, delayBetweenTriesMs }: {
+    maxCommitRetries: any;
+    delayBetweenTriesMs: any;
+}): {
+    get: (type: any, ids: any) => Promise<any>;
+    set: (data: any) => Promise<void>;
+    isInTransaction: () => boolean;
+    transaction: (work: any, key: any) => Promise<any>;
+};
+export function assertMeId(creds: any): any;
+export function initAuthCreds(): {
+    noiseKey: {
+        private: any;
+        public: any;
+    };
+    pairingEphemeralKeyPair: {
+        private: any;
+        public: any;
+    };
+    signedIdentityKey: {
+        private: any;
+        public: any;
+    };
+    signedPreKey: {
+        keyPair: {
+            private: any;
+            public: any;
+        };
+        signature: any;
+        keyId: any;
+    };
+    registrationId: number;
+    advSecretKey: any;
+    processedHistoryMessages: never[];
+    nextPreKeyId: number;
+    firstUnuploadedPreKeyId: number;
+    accountSyncCounter: number;
+    accountSettings: {
+        unarchiveChats: boolean;
+    };
+    registered: boolean;
+    pairingCode: undefined;
+    lastPropHash: undefined;
+    routingInfo: undefined;
+    additionalData: undefined;
+};

package/lib/Utils/auth-utils.js

@@ -0,0 +1,307 @@
+import NodeCache from '@cacheable/node-cache';
+import { Boom } from '@hapi/boom';
+import { AsyncLocalStorage } from 'async_hooks';
+import { Mutex } from 'async-mutex';
+import { randomBytes } from 'crypto';
+import PQueue from 'p-queue';
+import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
+import { Curve, signedKeyPair } from './crypto.js';
+import { delay, generateRegistrationId } from './generics.js';
+import { PreKeyManager } from './pre-key-manager.js';
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache ||
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+            useClones: false,
+            deleteOnExpire: true
+        });
+    // Mutex for protecting cache operations
+    const cacheMutex = new Mutex();
+    function getUniqueId(type, id) {
+        return `${type}.${id}`;
+    }
+    return {
+        async get(type, ids) {
+            return cacheMutex.runExclusive(async () => {
+                const data = {};
+                const idsToFetch = [];
+                for (const id of ids) {
+                    const item = (await cache.get(getUniqueId(type, id)));
+                    if (typeof item !== 'undefined') {
+                        data[id] = item;
+                    }
+                    else {
+                        idsToFetch.push(id);
+                    }
+                }
+                if (idsToFetch.length) {
+                    logger?.trace({ items: idsToFetch.length }, 'loading from store');
+                    const fetched = await store.get(type, idsToFetch);
+                    for (const id of idsToFetch) {
+                        const item = fetched[id];
+                        if (item) {
+                            data[id] = item;
+                            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                            await cache.set(getUniqueId(type, id), item);
+                        }
+                    }
+                }
+                return data;
+            });
+        },
+        async set(data) {
+            return cacheMutex.runExclusive(async () => {
+                let keys = 0;
+                for (const type in data) {
+                    for (const id in data[type]) {
+                        await cache.set(getUniqueId(type, id), data[type][id]);
+                        keys += 1;
+                    }
+                }
+                logger?.trace({ keys }, 'updated cache');
+                await store.set(data);
+            });
+        },
+        async clear() {
+            await cache.flushAll();
+            await store.clear?.();
+        }
+    };
+}
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    const txStorage = new AsyncLocalStorage();
+    // Queues for concurrency control (keyed by signal data type - bounded set)
+    const keyQueues = new Map();
+    // Transaction mutexes with reference counting for cleanup
+    const txMutexes = new Map();
+    const txMutexRefCounts = new Map();
+    // Pre-key manager for specialized operations
+    const preKeyManager = new PreKeyManager(state, logger);
+    /**
+     * Get or create a queue for a specific key type
+     */
+    function getQueue(key) {
+        if (!keyQueues.has(key)) {
+            keyQueues.set(key, new PQueue({ concurrency: 1 }));
+        }
+        return keyQueues.get(key);
+    }
+    /**
+     * Get or create a transaction mutex
+     */
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, new Mutex());
+            txMutexRefCounts.set(key, 0);
+        }
+        return txMutexes.get(key);
+    }
+    /**
+     * Acquire a reference to a transaction mutex
+     */
+    function acquireTxMutexRef(key) {
+        const count = txMutexRefCounts.get(key) ?? 0;
+        txMutexRefCounts.set(key, count + 1);
+    }
+    /**
+     * Release a reference to a transaction mutex and cleanup if no longer needed
+     */
+    function releaseTxMutexRef(key) {
+        const count = (txMutexRefCounts.get(key) ?? 1) - 1;
+        txMutexRefCounts.set(key, count);
+        // Cleanup if no more references and mutex is not locked
+        if (count <= 0) {
+            const mutex = txMutexes.get(key);
+            if (mutex && !mutex.isLocked()) {
+                txMutexes.delete(key);
+                txMutexRefCounts.delete(key);
+            }
+        }
+    }
+    /**
+     * Check if currently in a transaction
+     */
+    function isInTransaction() {
+        return !!txStorage.getStore();
+    }
+    /**
+     * Commit transaction with retries
+     */
+    async function commitWithRetry(mutations) {
+        if (Object.keys(mutations).length === 0) {
+            logger.trace('no mutations in transaction');
+            return;
+        }
+        logger.trace('committing transaction');
+        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+            try {
+                await state.set(mutations);
+                logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction');
+                return;
+            }
+            catch (error) {
+                const retriesLeft = maxCommitRetries - attempt - 1;
+                logger.warn(`failed to commit mutations, retries left=${retriesLeft}`);
+                if (retriesLeft === 0) {
+                    throw error;
+                }
+                await delay(delayBetweenTriesMs);
+            }
+        }
+    }
+    return {
+        get: async (type, ids) => {
+            const ctx = txStorage.getStore();
+            if (!ctx) {
+                // No transaction - direct read without exclusive lock for concurrency
+                return state.get(type, ids);
+            }
+            // In transaction - check cache first
+            const cached = ctx.cache[type] || {};
+            const missing = ids.filter(id => !(id in cached));
+            if (missing.length > 0) {
+                ctx.dbQueries++;
+                logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction');
+                const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing));
+                // Update cache
+                ctx.cache[type] = ctx.cache[type] || {};
+                Object.assign(ctx.cache[type], fetched);
+            }
+            // Return requested ids from cache
+            const result = {};
+            for (const id of ids) {
+                const value = ctx.cache[type]?.[id];
+                if (value !== undefined && value !== null) {
+                    result[id] = value;
+                }
+            }
+            return result;
+        },
+        set: async (data) => {
+            const ctx = txStorage.getStore();
+            if (!ctx) {
+                // No transaction - direct write with queue protection
+                const types = Object.keys(data);
+                // Vanz@Fix (bug 66): validateDeletions() used to run *before* this,
+                // serialized only against PreKeyManager's own internal queue —
+                // a separate PQueue instance from getQueue(type) below, both keyed
+                // 'pre-key' but never synchronized with each other. Two concurrent
+                // set() calls for pre-key data could validate against a store state
+                // that a still-pending write from the other call hadn't applied yet,
+                // letting a stale deletion go through or a just-deleted key get
+                // resurrected by data racing back in. Validation now happens inside
+                // the same per-type queue job as the write, so it's ordered against
+                // any other set() for that type instead of racing it.
+                await Promise.all(types.map(type => getQueue(type).add(async () => {
+                    if (type === 'pre-key') {
+                        await preKeyManager.validateDeletions(data, type);
+                    }
+                    const typeData = { [type]: data[type] };
+                    await state.set(typeData);
+                })));
+                return;
+            }
+            // In transaction - update cache and mutations
+            logger.trace({ types: Object.keys(data) }, 'caching in transaction');
+            for (const key_ in data) {
+                const key = key_;
+                // Ensure structures exist
+                ctx.cache[key] = ctx.cache[key] || {};
+                ctx.mutations[key] = ctx.mutations[key] || {};
+                // Special handling for pre-keys
+                if (key === 'pre-key') {
+                    await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
+                }
+                else {
+                    // Normal key types
+                    Object.assign(ctx.cache[key], data[key]);
+                    Object.assign(ctx.mutations[key], data[key]);
+                }
+            }
+        },
+        isInTransaction,
+        transaction: async (work, key) => {
+            const existing = txStorage.getStore();
+            // Nested transaction - reuse existing context
+            if (existing) {
+                logger.trace('reusing existing transaction context');
+                return work();
+            }
+            // New transaction - acquire mutex and create context
+            const mutex = getTxMutex(key);
+            acquireTxMutexRef(key);
+            try {
+                return await mutex.runExclusive(async () => {
+                    const ctx = {
+                        cache: {},
+                        mutations: {},
+                        dbQueries: 0
+                    };
+                    logger.trace('entering transaction');
+                    try {
+                        const result = await txStorage.run(ctx, work);
+                        // Commit mutations
+                        await commitWithRetry(ctx.mutations);
+                        logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
+                        return result;
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'transaction failed, rolling back');
+                        throw error;
+                    }
+                });
+            }
+            finally {
+                releaseTxMutexRef(key);
+            }
+        }
+    };
+};
+/**
+ * Returns the authenticated user's JID, or throws a Boom-401 if creds are not yet authenticated.
+ * Use this anywhere we'd otherwise reach for `creds.me!.id` to fail fast with a descriptive error.
+ */
+export const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
+};
+export const initAuthCreds = () => {
+    const identityKey = Curve.generateKeyPair();
+    return {
+        noiseKey: Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: signedKeyPair(identityKey, 1),
+        registrationId: generateRegistrationId(),
+        advSecretKey: randomBytes(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined
+    };
+};
+//# sourceMappingURL=auth-utils.js.map