queenruva-sockets 5.6.23

package/lib/Utils/identity-change-handler.js

@@ -0,0 +1,50 @@
+import NodeCache from '@cacheable/node-cache';
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
+import { isStringNullOrEmpty } from './generics.js';
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = getBinaryNodeChild(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = jidDecode(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    ctx.onBeforeSessionRefresh?.(from);
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}
+//# sourceMappingURL=identity-change-handler.js.map

package/lib/Utils/index.d.ts

@@ -0,0 +1,22 @@
+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 './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.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';
+//# sourceMappingURL=index.d.ts.map

package/lib/Utils/index.js

@@ -0,0 +1,22 @@
+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 './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.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';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,21 @@
+import type { WAMediaUploadFunction, WAUrlInfo } from '../Types/index.js';
+import type { ILogger } from './logger.js';
+export type URLGenerationOptions = {
+    thumbnailWidth: number;
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number;
+        proxyUrl?: string;
+        headers?: HeadersInit;
+    };
+    uploadImage?: WAMediaUploadFunction;
+    logger?: ILogger;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>;
+//# sourceMappingURL=link-preview.d.ts.map

package/lib/Utils/link-preview.js

@@ -0,0 +1,85 @@
+import { prepareWAMessageMedia } from './messages.js';
+import { extractImageThumb, getHttpStream } from './messages-media.js';
+const THUMBNAIL_WIDTH_PX = 192;
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+export const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    try {
+        // retries
+        let retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries += 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts?.headers
+        });
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images;
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};
+//# sourceMappingURL=link-preview.js.map

package/lib/Utils/logger.d.ts

@@ -0,0 +1,12 @@
+export interface ILogger {
+    level: string;
+    child(obj: Record<string, unknown>): ILogger;
+    trace(obj: unknown, msg?: string): void;
+    debug(obj: unknown, msg?: string): void;
+    info(obj: unknown, msg?: string): void;
+    warn(obj: unknown, msg?: string): void;
+    error(obj: unknown, msg?: string): void;
+}
+declare const _default: import("pino").Logger<never, boolean>;
+export default _default;
+//# sourceMappingURL=logger.d.ts.map

package/lib/Utils/logger.js

@@ -0,0 +1,3 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+//# sourceMappingURL=logger.js.map

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

@@ -0,0 +1,8 @@
+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.
+ */
+export declare const LT_HASH_ANTI_TAMPERING: LTHashAntiTampering;
+//# sourceMappingURL=lt-hash.d.ts.map

package/lib/Utils/lt-hash.js

@@ -0,0 +1,8 @@
+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.
+ */
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();
+//# sourceMappingURL=lt-hash.js.map

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

@@ -0,0 +1,9 @@
+export declare const makeMutex: () => {
+    mutex<T>(code: () => Promise<T> | T): Promise<T>;
+};
+export type Mutex = ReturnType<typeof makeMutex>;
+export declare const makeKeyedMutex: () => {
+    mutex<T>(key: string, task: () => Promise<T> | T): Promise<T>;
+};
+export type KeyedMutex = ReturnType<typeof makeKeyedMutex>;
+//# sourceMappingURL=make-mutex.d.ts.map

package/lib/Utils/make-mutex.js

@@ -0,0 +1,33 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = new Map();
+    return {
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
+            }
+        }
+    };
+};
+//# sourceMappingURL=make-mutex.js.map

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

@@ -0,0 +1,115 @@
+import type { proto } from '../../WAProto/index.js';
+import type { ILogger } from './logger.js';
+export interface RecentMessageKey {
+    to: string;
+    id: string;
+}
+export interface RecentMessage {
+    message: proto.IMessage;
+    timestamp: number;
+}
+export interface SessionRecreateHistory {
+    [jid: string]: number;
+}
+export interface RetryCounter {
+    [messageId: string]: number;
+}
+export type PendingPhoneRequest = Record<string, ReturnType<typeof setTimeout>>;
+export interface RetryStatistics {
+    totalRetries: number;
+    successfulRetries: number;
+    failedRetries: number;
+    mediaRetries: number;
+    sessionRecreations: number;
+    phoneRequests: number;
+}
+export declare enum RetryReason {
+    UnknownError = 0,
+    SignalErrorNoSession = 1,
+    SignalErrorInvalidKey = 2,
+    SignalErrorInvalidKeyId = 3,
+    /** MAC verification failed - most common cause of decryption failures */
+    SignalErrorInvalidMessage = 4,
+    SignalErrorInvalidSignature = 5,
+    SignalErrorFutureMessage = 6,
+    /** Explicit MAC failure - session is definitely out of sync */
+    SignalErrorBadMac = 7,
+    SignalErrorInvalidSession = 8,
+    SignalErrorInvalidMsgKey = 9,
+    BadBroadcastEphemeralSetting = 10,
+    UnknownCompanionNoPrekey = 11,
+    AdvFailure = 12,
+    StatusRevokeDelay = 13
+}
+export declare class MessageRetryManager {
+    private logger;
+    private recentMessagesMap;
+    private messageKeyIndex;
+    private sessionRecreateHistory;
+    private retryCounters;
+    private baseKeys;
+    private pendingPhoneRequests;
+    private readonly maxMsgRetryCount;
+    private statistics;
+    constructor(logger: ILogger, maxMsgRetryCount: number);
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: string, id: string, message: proto.IMessage): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: string, id: string): RecentMessage | undefined;
+    /**
+     * 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: string, hasSession: boolean, errorCode?: RetryReason): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: string | undefined): RetryReason | undefined;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: RetryReason | undefined): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: string): number;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: string): number;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: string): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: string): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: string): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: string): void;
+    clear(): void;
+    saveBaseKey(addr: string, msgId: string, baseKey: Uint8Array): void;
+    hasSameBaseKey(addr: string, msgId: string, baseKey: Uint8Array): boolean;
+    deleteBaseKey(addr: string, msgId: string): void;
+    private keyToString;
+    private removeRecentMessage;
+}
+//# sourceMappingURL=message-retry-manager.d.ts.map

package/lib/Utils/message-retry-manager.js

@@ -0,0 +1,265 @@
+import { LRUCache } from 'lru-cache';
+/** Number of sent messages to cache in memory for handling retry receipts */
+const RECENT_MESSAGES_SIZE = 512;
+const MESSAGE_KEY_SEPARATOR = '\u0000';
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
+const PHONE_REQUEST_DELAY = 3000;
+// Retry reason codes matching WhatsApp Web's Signal error codes.
+export var RetryReason;
+(function (RetryReason) {
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+    /** MAC verification failed - most common cause of decryption failures */
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+    /** Explicit MAC failure - session is definitely out of sync */
+    RetryReason[RetryReason["SignalErrorBadMac"] = 7] = "SignalErrorBadMac";
+    RetryReason[RetryReason["SignalErrorInvalidSession"] = 8] = "SignalErrorInvalidSession";
+    RetryReason[RetryReason["SignalErrorInvalidMsgKey"] = 9] = "SignalErrorInvalidMsgKey";
+    RetryReason[RetryReason["BadBroadcastEphemeralSetting"] = 10] = "BadBroadcastEphemeralSetting";
+    RetryReason[RetryReason["UnknownCompanionNoPrekey"] = 11] = "UnknownCompanionNoPrekey";
+    RetryReason[RetryReason["AdvFailure"] = 12] = "AdvFailure";
+    RetryReason[RetryReason["StatusRevokeDelay"] = 13] = "StatusRevokeDelay";
+})(RetryReason || (RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */
+const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
+export class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger;
+        this.recentMessagesMap = new LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            ttlAutopurge: true,
+            dispose: (_value, key) => {
+                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+                if (separatorIndex > -1) {
+                    const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length);
+                    this.messageKeyIndex.delete(messageId);
+                }
+            }
+        });
+        this.messageKeyIndex = new Map();
+        this.sessionRecreateHistory = new LRUCache({
+            ttl: RECREATE_SESSION_TIMEOUT * 2,
+            ttlAutopurge: true
+        });
+        this.retryCounters = new LRUCache({
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        }); // 15 minutes TTL
+        this.baseKeys = new LRUCache({
+            max: 1024,
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true
+        });
+        this.pendingPhoneRequests = {};
+        this.maxMsgRetryCount = 5;
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+        this.maxMsgRetryCount = maxMsgRetryCount;
+    }
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to, id, message) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        // Add new message
+        this.recentMessagesMap.set(keyStr, {
+            message,
+            timestamp: Date.now()
+        });
+        this.messageKeyIndex.set(id, keyStr);
+        this.logger.debug(`Added message to retry cache: ${to}/${id}`);
+    }
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to, id) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        return this.recentMessagesMap.get(keyStr);
+    }
+    /**
+     * 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, hasSession, errorCode) {
+        // If we don't have a session, always recreate
+        if (!hasSession) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            return {
+                reason: "we don't have a Signal session with them",
+                recreate: true
+            };
+        }
+        // IMMEDIATE recreation for MAC errors - session is definitely out of sync
+        if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            this.logger.warn({ jid, errorCode: RetryReason[errorCode] }, 'MAC error detected, forcing immediate session recreation');
+            return {
+                reason: `MAC error (code ${errorCode}: ${RetryReason[errorCode]}), immediate session recreation`,
+                recreate: true
+            };
+        }
+        const now = Date.now();
+        const prevTime = this.sessionRecreateHistory.get(jid);
+        // If no previous recreation or it's been more than an hour
+        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
+            this.sessionRecreateHistory.set(jid, now);
+            this.statistics.sessionRecreations++;
+            return {
+                reason: 'retry count > 1 and over an hour since last recreation',
+                recreate: true
+            };
+        }
+        return { reason: '', recreate: false };
+    }
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr) {
+        if (errorAttr === undefined || errorAttr === '') {
+            return undefined;
+        }
+        const code = parseInt(errorAttr, 10);
+        if (Number.isNaN(code)) {
+            return undefined;
+        }
+        // Validate it's a known RetryReason
+        if (code >= RetryReason.UnknownError && code <= RetryReason.StatusRevokeDelay) {
+            return code;
+        }
+        return RetryReason.UnknownError;
+    }
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode) {
+        return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
+    }
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId) {
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
+        this.statistics.totalRetries++;
+        return this.retryCounters.get(messageId);
+    }
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId) {
+        return this.retryCounters.get(messageId) || 0;
+    }
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId) {
+        return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
+    }
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId) {
+        this.statistics.successfulRetries++;
+        // Clean up retry counter for successful message
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++;
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        // Cancel any existing request for this message
+        this.cancelPendingPhoneRequest(messageId);
+        this.pendingPhoneRequests[messageId] = setTimeout(() => {
+            delete this.pendingPhoneRequests[messageId];
+            this.statistics.phoneRequests++;
+            callback();
+        }, delay);
+        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`);
+    }
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId) {
+        const timeout = this.pendingPhoneRequests[messageId];
+        if (timeout) {
+            clearTimeout(timeout);
+            delete this.pendingPhoneRequests[messageId];
+            this.logger.debug(`Cancelled pending phone request for message ${messageId}`);
+        }
+    }
+    clear() {
+        this.recentMessagesMap.clear();
+        this.messageKeyIndex.clear();
+        this.sessionRecreateHistory.clear();
+        this.retryCounters.clear();
+        this.baseKeys.clear();
+        for (const messageId of Object.keys(this.pendingPhoneRequests)) {
+            this.cancelPendingPhoneRequest(messageId);
+        }
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+    }
+    saveBaseKey(addr, msgId, baseKey) {
+        this.baseKeys.set(`${addr}:${msgId}`, baseKey);
+    }
+    hasSameBaseKey(addr, msgId, baseKey) {
+        const stored = this.baseKeys.get(`${addr}:${msgId}`);
+        if (!stored || stored.length !== baseKey.length) {
+            return false;
+        }
+        for (let i = 0; i < stored.length; i++) {
+            if (stored[i] !== baseKey[i])
+                return false;
+        }
+        return true;
+    }
+    deleteBaseKey(addr, msgId) {
+        this.baseKeys.delete(`${addr}:${msgId}`);
+    }
+    keyToString(key) {
+        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+    }
+    removeRecentMessage(messageId) {
+        const keyStr = this.messageKeyIndex.get(messageId);
+        if (!keyStr) {
+            return;
+        }
+        this.recentMessagesMap.delete(keyStr);
+        this.messageKeyIndex.delete(messageId);
+    }
+}
+//# sourceMappingURL=message-retry-manager.js.map