@vanzxy/baileys 1.3.7 → 1.3.8

package/lib/Utils/history.d.ts

@@ -0,0 +1,90 @@
+export function downloadHistory(msg: any, options: any): Promise<any>;
+export function processHistoryMessage(item: any, logger: any): {
+    messages: any[];
+    contacts: any[];
+    chats: any[];
+    lidPnMappings: any[];
+    pastParticipants?: undefined;
+    syncType?: undefined;
+    progress?: undefined;
+} | {
+    chats: any[];
+    contacts: ({
+        id: any;
+        name: any;
+        username: any;
+        lid: any;
+        phoneNumber: any;
+        verifiedName?: undefined;
+        notify?: undefined;
+    } | {
+        id: any;
+        verifiedName: any;
+        name?: undefined;
+        username?: undefined;
+        lid?: undefined;
+        phoneNumber?: undefined;
+        notify?: undefined;
+    } | {
+        id: any;
+        notify: any;
+        name?: undefined;
+        username?: undefined;
+        lid?: undefined;
+        phoneNumber?: undefined;
+        verifiedName?: undefined;
+    })[];
+    messages: any[];
+    lidPnMappings: {
+        lid: any;
+        pn: any;
+    }[];
+    pastParticipants: any;
+    syncType: any;
+    progress: any;
+};
+export function downloadAndProcessHistorySyncNotification(msg: any, options: any, logger: any): Promise<{
+    messages: any[];
+    contacts: any[];
+    chats: any[];
+    lidPnMappings: any[];
+    pastParticipants?: undefined;
+    syncType?: undefined;
+    progress?: undefined;
+} | {
+    chats: any[];
+    contacts: ({
+        id: any;
+        name: any;
+        username: any;
+        lid: any;
+        phoneNumber: any;
+        verifiedName?: undefined;
+        notify?: undefined;
+    } | {
+        id: any;
+        verifiedName: any;
+        name?: undefined;
+        username?: undefined;
+        lid?: undefined;
+        phoneNumber?: undefined;
+        notify?: undefined;
+    } | {
+        id: any;
+        notify: any;
+        name?: undefined;
+        username?: undefined;
+        lid?: undefined;
+        phoneNumber?: undefined;
+        verifiedName?: undefined;
+    })[];
+    messages: any[];
+    lidPnMappings: {
+        lid: any;
+        pn: any;
+    }[];
+    pastParticipants: any;
+    syncType: any;
+    progress: any;
+}>;
+export function getHistoryMsg(message: any): any;

package/lib/Utils/identity-change-handler.d.ts

@@ -0,0 +1,13 @@
+export function handleIdentityChange(node: any, ctx: any): Promise<{
+    action: string;
+    device?: undefined;
+    error?: undefined;
+} | {
+    action: string;
+    device: number;
+    error?: undefined;
+} | {
+    action: string;
+    error: unknown;
+    device?: undefined;
+}>;

package/lib/Utils/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./generics.js";
+export * from "./decode-wa-message.js";
+export * from "./messages.js";
+export * from "./messages-media.js";
+export * from "./validate-connection.js";
+export * from "./crypto.js";
+export * from "./signal.js";
+export * from "./noise-handler.js";
+export * from "./history.js";
+export * from "./chat-utils.js";
+export * from "./lt-hash.js";
+export * from "./auth-utils.js";
+export * from "./use-multi-file-auth-state.js";
+export * from "./use-single-file-auth-state.js";
+export * from "./use-sqlite-auth-state.js";
+export * from "./link-preview.js";
+export * from "./event-buffer.js";
+export * from "./process-message.js";
+export * from "./rich-message-utils.js";
+export * from "./message-retry-manager.js";
+export * from "./browser-utils.js";
+export * from "./companion-reg-client-utils.js";
+export * from "./identity-change-handler.js";
+export * from "./stanza-ack.js";

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,12 @@
+export function getUrlInfo(text: any, opts?: {
+    thumbnailWidth: number;
+    fetchOpts: {
+        timeout: number;
+    };
+}): Promise<{
+    'canonical-url': any;
+    'matched-text': any;
+    title: any;
+    description: any;
+    originalThumbnailUrl: any;
+} | undefined>;

package/lib/Utils/logger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ *
+ * Vanz@Fix (bug 36 follow-up): whatsapp-rust-bridge is a native module and was previously
+ * statically imported here, which crashed the *entire* library at import time on platforms
+ * without a prebuilt binary (ARM musl/Alpine/Termux/some Pterodactyl nodes) — even for bots
+ * that never touch app-state sync. Same top-level-await try/catch pattern as crypto.js:
+ * only throws (with a clear message) if app-state sync (LT hash) is actually used.
+ */
+export let LT_HASH_ANTI_TAMPERING: any;

package/lib/Utils/lt-hash.js

@@ -1,8 +1,27 @@
-import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
 /**
  * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
  * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
  * if the same series of mutations was made sequentially.
+ *
+ * Vanz@Fix (bug 36 follow-up): whatsapp-rust-bridge is a native module and was previously
+ * statically imported here, which crashed the *entire* library at import time on platforms
+ * without a prebuilt binary (ARM musl/Alpine/Termux/some Pterodactyl nodes) — even for bots
+ * that never touch app-state sync. Same top-level-await try/catch pattern as crypto.js:
+ * only throws (with a clear message) if app-state sync (LT hash) is actually used.
  */
-export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+let LT_HASH_ANTI_TAMPERING;
+try {
+    const { LTHashAntiTampering } = await import('whatsapp-rust-bridge');
+    LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+}
+catch (err) {
+    const message = '`whatsapp-rust-bridge` failed to load (no prebuilt binary for this platform/arch). ' +
+        'App-state sync (LT hash) is unavailable here. Original error: ' + (err?.message || err);
+    LT_HASH_ANTI_TAMPERING = new Proxy({}, {
+        get() {
+            throw new Error(message);
+        }
+    });
+}
+export { LT_HASH_ANTI_TAMPERING };
 //# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,6 @@
+export function makeMutex(): {
+    mutex(code: any): any;
+};
+export function makeKeyedMutex(): {
+    mutex(key: any, task: any): Promise<any>;
+};

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,79 @@
+export const RetryReason: any;
+export class MessageRetryManager {
+    constructor(logger: any, maxMsgRetryCount: any);
+    logger: any;
+    recentMessagesMap: any;
+    messageKeyIndex: Map<any, any>;
+    sessionRecreateHistory: any;
+    retryCounters: any;
+    baseKeys: any;
+    pendingPhoneRequests: {};
+    maxMsgRetryCount: any;
+    statistics: {
+        totalRetries: number;
+        successfulRetries: number;
+        failedRetries: number;
+        mediaRetries: number;
+        sessionRecreations: number;
+        phoneRequests: number;
+    };
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: any, id: any, message: any): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: any, id: any): any;
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid: any, hasSession: any, errorCode: any): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: any): any;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: any): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: any): any;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: any): any;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: any): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: any): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: any): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: any, callback: any, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: any): void;
+    clear(): void;
+    saveBaseKey(addr: any, msgId: any, baseKey: any): void;
+    hasSameBaseKey(addr: any, msgId: any, baseKey: any): boolean;
+    deleteBaseKey(addr: any, msgId: any): void;
+    keyToString(key: any): string;
+    removeRecentMessage(messageId: any): void;
+}

package/lib/Utils/messages-media.d.ts

@@ -0,0 +1,135 @@
+/** generates all the keys required to encrypt/decrypt & sign a media message */
+export function getMediaKeys(buffer: any, mediaType: any): Promise<{
+    iv: any;
+    cipherKey: any;
+    macKey: any;
+}>;
+export function getAudioDuration(buffer: any): Promise<any>;
+/**
+  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
+ */
+export function getAudioWaveform(buffer: any, logger: any): Promise<Uint8Array<ArrayBuffer> | undefined>;
+/** generates a thumbnail for a given media, if required */
+export function generateThumbnail(file: any, mediaType: any, options: any): Promise<{
+    thumbnail: any;
+    originalImageDimensions: {
+        width: any;
+        height: any;
+    } | undefined;
+}>;
+export function extensionForMediaMessage(message: any): any;
+export function getImageProcessingLibrary(): Promise<any>;
+export function hkdfInfoKey(type: any): string;
+export function getRawMediaUploadData(media: any, mediaType: any, logger: any): Promise<{
+    filePath: any;
+    fileSha256: any;
+    fileLength: number;
+}>;
+export function extractVideoThumb(path: any, time: any, size: any): Promise<any>;
+export function extractImageThumb(bufferOrFilePath: any, width?: number): Promise<{
+    buffer: any;
+    original: {
+        width: any;
+        height: any;
+    };
+}>;
+export function encodeBase64EncodedStringForUpload(b64: any): string;
+export function generateProfilePicture(mediaUpload: any, dimensions: any): Promise<{
+    img: any;
+}>;
+export function mediaMessageSHA256B64(message: any): any;
+export function toReadable(buffer: any): any;
+export function toBuffer(stream: any): Promise<any>;
+export function getStream(item: any, opts: any): Promise<{
+    stream: any;
+    type: string;
+}>;
+export function getHttpStream(url: any, options?: {}): Promise<any>;
+export function encryptedStream(media: any, mediaType: any, { logger, saveOriginalFileIfRequired, opts }?: {}): Promise<{
+    mediaKey: any;
+    originalFilePath: any;
+    encFilePath: any;
+    mac: any;
+    fileEncSha256: any;
+    fileSha256: any;
+    fileLength: number;
+}>;
+export const DEF_MEDIA_HOST: "mmg.whatsapp.net";
+export function getUrlFromDirectPath(directPath: any, host?: string): string;
+export function downloadContentFromMessage({ mediaKey, directPath, url }: {
+    mediaKey: any;
+    directPath: any;
+    url: any;
+}, type: any, opts?: {}): Promise<any>;
+export function downloadEncryptedContent(downloadUrl: any, { cipherKey, iv }: {
+    cipherKey: any;
+    iv: any;
+}, { startByte, endByte, options }?: {}): Promise<any>;
+export function uploadWithNodeHttp({ url, filePath, headers, timeoutMs, agent }: {
+    url: any;
+    filePath: any;
+    headers: any;
+    timeoutMs: any;
+    agent: any;
+}, redirectCount?: number): Promise<any>;
+export function getWAUploadToServer({ customUploadHosts, fetchAgent, logger, options }: {
+    customUploadHosts: any;
+    fetchAgent: any;
+    logger: any;
+    options: any;
+}, refreshMediaConn: any): (filePath: any, { mediaType, fileEncSha256B64, timeoutMs, newsletter }: {
+    mediaType: any;
+    fileEncSha256B64: any;
+    timeoutMs: any;
+    newsletter: any;
+}) => Promise<{
+    mediaUrl: any;
+    directPath: any;
+    meta_hmac: any;
+    fbid: any;
+    ts: any;
+    thumbnailDirectPath: any;
+    thumbnailSha256: any;
+}>;
+export function encryptMediaRetryRequest(key: any, mediaKey: any, meId: any): {
+    tag: string;
+    attrs: {
+        id: any;
+        to: string;
+        type: string;
+    };
+    content: ({
+        tag: string;
+        attrs: {
+            jid?: undefined;
+            from_me?: undefined;
+            participant?: undefined;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    } | {
+        tag: string;
+        attrs: {
+            jid: any;
+            from_me: string;
+            participant: any;
+        };
+        content?: undefined;
+    })[];
+};
+export function decodeMediaRetryNode(node: any): {
+    key: {
+        id: any;
+        remoteJid: any;
+        fromMe: boolean;
+        participant: any;
+    };
+};
+export function decryptMediaRetryData({ ciphertext, iv }: {
+    ciphertext: any;
+    iv: any;
+}, mediaKey: any, msgId: any): any;
+export function getStatusCodeForMediaRetry(code: any): number;

package/lib/Utils/messages.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Aggregates all poll updates in a poll.
+ * @param msg the poll creation message
+ * @param meId your jid
+ * @returns A list of options & their voters
+ */
+export function getAggregateVotesInPollMessage({ message, pollUpdates }: {
+    message: any;
+    pollUpdates: any;
+}, meId: any): any[];
+/**
+ * Aggregates all event responses in an event message.
+ * @param msg the event creation message
+ * @param meId your jid
+ * @returns A list of response types & their responders
+ */
+export function getAggregateResponsesInEventMessage({ eventResponses }: {
+    eventResponses: any;
+}, meId: any): any[];
+export function extractUrlFromText(text: any): any;
+export function generateLinkPreviewIfRequired(text: any, getUrlInfo: any, logger: any): Promise<any>;
+export function prepareWAMessageMedia(message: any, options: any): Promise<any>;
+export function prepareDisappearingMessageSettingContent(ephemeralExpiration: any): any;
+export function generateForwardMessageContent(message: any, forceForward: any): any;
+export function hasNonNullishProperty(message: any, key: any): boolean;
+export function hasOptionalProperty(obj: any, key: any): boolean;
+export function hasValidAlbumMedia(message: any): boolean;
+export function hasValidInteractiveHeader(message: any): boolean;
+export function hasValidCarouselHeader(message: any): boolean;
+export function generateWAMessageContent(message: any, options: any): Promise<any>;
+export function generateWAMessageFromContent(jid: any, message: any, options: any): any;
+export function generateWAMessage(jid: any, content: any, options: any): Promise<any>;
+export function getContentType(content: any): string | undefined;
+export function normalizeMessageContent(content: any): any;
+export function extractMessageContent(content: any): any;
+export function getDevice(id: any): "web" | "unknown" | "android" | "ios" | "desktop";
+export function updateMessageWithReceipt(msg: any, receipt: any): void;
+export function updateMessageWithReaction(msg: any, reaction: any): void;
+export function updateMessageWithPollUpdate(msg: any, update: any): void;
+export function updateMessageWithEventResponse(msg: any, update: any): void;
+export function aggregateMessageKeysNotFromMe(keys: any): any[];
+export function downloadMediaMessage(message: any, type: any, options: any, ctx: any): Promise<any>;
+export function assertMediaContent(content: any): any;
+export function shouldIncludeBizBinaryNode(message: any): boolean;

package/lib/Utils/noise-handler.d.ts

@@ -0,0 +1,20 @@
+export function makeNoiseHandler({ keyPair: { private: privateKey, public: publicKey }, NOISE_HEADER, logger, routingInfo }: {
+    keyPair: {
+        private: any;
+        public: any;
+    };
+    NOISE_HEADER: any;
+    logger: any;
+    routingInfo: any;
+}): {
+    encrypt: (plaintext: any) => any;
+    decrypt: (ciphertext: any) => any;
+    authenticate: (data: any) => void;
+    mixIntoKey: (data: any) => void;
+    finishInit: () => Promise<void>;
+    processHandshake: ({ serverHello }: {
+        serverHello: any;
+    }, noiseKey: any) => any;
+    encodeFrame: (data: any) => any;
+    decodeFrame: (newData: any, onFrame: any) => Promise<void>;
+};

package/lib/Utils/offline-node-processor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export function makeOfflineNodeProcessor(nodeProcessorMap: any, deps: any, batchSize?: number): {
+    enqueue: (type: any, node: any) => void;
+};

package/lib/Utils/pre-key-manager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Manages pre-key operations with proper concurrency control
+ */
+export class PreKeyManager {
+    constructor(store: any, logger: any);
+    store: any;
+    logger: any;
+    queues: Map<any, any>;
+    /**
+     * Get or create a queue for a specific key type
+     */
+    getQueue(keyType: any): any;
+    /**
+     * Process pre-key operations (updates and deletions)
+     */
+    processOperations(data: any, keyType: any, transactionCache: any, mutations: any, isInTransaction: any): Promise<any>;
+    /**
+     * Process deletions with validation
+     */
+    processDeletions(keyType: any, ids: any, transactionCache: any, mutations: any, isInTransaction: any): Promise<void>;
+    /**
+     * Validate and process pre-key deletions outside transactions
+     */
+    validateDeletions(data: any, keyType: any): Promise<any>;
+}

package/lib/Utils/process-message.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
+export function decryptPollVote({ encPayload, encIv }: {
+    encPayload: any;
+    encIv: any;
+}, { pollCreatorJid, pollMsgId, pollEncKey, voterJid }: {
+    pollCreatorJid: any;
+    pollMsgId: any;
+    pollEncKey: any;
+    voterJid: any;
+}): any;
+/**
+ * Decrypt an event response
+ * @param response encrypted event response
+ * @param ctx additional info about the event required for decryption
+ * @returns event response message
+ */
+export function decryptEventResponse({ encPayload, encIv }: {
+    encPayload: any;
+    encIv: any;
+}, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }: {
+    eventCreatorJid: any;
+    eventMsgId: any;
+    eventEncKey: any;
+    responderJid: any;
+}): any;
+/**
+ * Decrypt a `secretEncryptedMessage` carrying a `MESSAGE_EDIT` payload.
+ *
+ * WhatsApp started wrapping message edits in an E2EE envelope (May 2026).
+ * The new content is encrypted with a key derived from the original
+ * message's `messageContextInfo.messageSecret` using HKDF-SHA256
+ * + AES-256-GCM, same family as polls and event responses but with
+ * different constants (validated against live WhatsApp Android traffic):
+ *
+ *   info = msgId || origSenderJid || editorJid || "Message Edit"
+ *   aad  = (empty)              <-- differs from Poll Vote / Event Response
+ *   key  = HKDF-SHA256(salt=zeros, ikm=messageSecret, info, L=32)
+ *
+ * The decrypted plaintext is a regular `proto.Message` whose
+ * `protocolMessage.editedMessage` field holds the new content — same
+ * shape as the legacy `protocolMessage.editedMessage` edit path, so
+ * consumers can treat the result identically.
+ *
+ * @param edit encrypted edit payload (encPayload + encIv from SecretEncryptedMessage)
+ * @param ctx info about the original message required for decryption
+ * @returns decoded outer `Message` whose `protocolMessage.editedMessage`
+ *   carries the new content (extendedTextMessage / conversation / etc.)
+ */
+export function decryptMessageEdit({ encPayload, encIv }: {
+    encPayload: any;
+    encIv: any;
+}, { originalSenderJid, originalMsgId, editEncKey, editorJid }: {
+    originalSenderJid: any;
+    originalMsgId: any;
+    editEncKey: any;
+    editorJid: any;
+}): any;
+export function cleanMessage(message: any, meId: any, meLid: any): void;
+export function isRealMessage(message: any): boolean;
+export function shouldIncrementChatUnread(message: any): boolean;
+export function getChatId({ remoteJid, participant, fromMe }: {
+    remoteJid: any;
+    participant: any;
+    fromMe: any;
+}): any;
+export default processMessage;
+declare function processMessage(message: any, { shouldProcessHistoryMsg, placeholderResendCache, ev, creds, signalRepository, keyStore, logger, options, getMessage }: {
+    shouldProcessHistoryMsg: any;
+    placeholderResendCache: any;
+    ev: any;
+    creds: any;
+    signalRepository: any;
+    keyStore: any;
+    logger: any;
+    options: any;
+    getMessage: any;
+}): Promise<void>;

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

@@ -0,0 +1,12 @@
+export function shouldIncludeReportingToken(message: any): boolean;
+export function getMessageReportingToken(msgProtobuf: any, message: any, key: any): Promise<{
+    tag: string;
+    attrs: {};
+    content: {
+        tag: string;
+        attrs: {
+            v: string;
+        };
+        content: any;
+    }[];
+} | null>;

package/lib/Utils/rich-message-utils.d.ts

@@ -0,0 +1,48 @@
+export function tokenizeCode(code: any, language?: string): {
+    highlightType: any;
+    codeContent: string;
+}[];
+export function toUnified(submessages: any, uuid: any): {
+    response_id: any;
+    sections: any;
+};
+export function prepareRichResponseMessage(content: any): {
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: {
+                    certificateChain: Uint8Array<ArrayBuffer>[];
+                    version: number;
+                    useCase: number;
+                    signature: Uint8Array<ArrayBuffer>;
+                }[];
+            };
+        };
+    };
+    botForwardedMessage: {
+        message: {
+            richResponseMessage: any;
+        };
+    };
+};
+export function botMetadataSignature(): Uint8Array<ArrayBuffer>;
+export function botMetadataCertificate(length?: number): Uint8Array<ArrayBuffer>;
+export function wrapToBotForwardedMessage(richResponseMessage: any): {
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: {
+                    certificateChain: Uint8Array<ArrayBuffer>[];
+                    version: number;
+                    useCase: number;
+                    signature: Uint8Array<ArrayBuffer>;
+                }[];
+            };
+        };
+    };
+    botForwardedMessage: {
+        message: {
+            richResponseMessage: any;
+        };
+    };
+};