@mrlegendbot/baileys 1.2.5 → 1.2.7

package/lib/Utils/make-mutex.js

@@ -1,33 +1,33 @@
 import { Mutex as AsyncMutex } from 'async-mutex';
 export const makeMutex = () => {
-  const mutex = new AsyncMutex();
-  return {
-    mutex(code) {
-      return mutex.runExclusive(code);
-    }
-  };
+    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--;
-        if (entry.refCount === 0 && map.get(key) === entry) {
-          map.delete(key);
+    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

@@ -1,224 +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';
-const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
+/** 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";
-  RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
-  RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
-  RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
-  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["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);
+    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;
         }
-      }
-    });
-    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
-    });
-    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;
-  }
-  addRecentMessage(to, id, message) {
-    const key = {
-      to,
-      id
-    };
-    const keyStr = this.keyToString(key);
-    this.recentMessagesMap.set(keyStr, {
-      message,
-      timestamp: Date.now()
-    });
-    this.messageKeyIndex.set(id, keyStr);
-    this.logger.debug(`Added message to retry cache: ${to}/${id}`);
-  }
-  getRecentMessage(to, id) {
-    const key = {
-      to,
-      id
-    };
-    const keyStr = this.keyToString(key);
-    return this.recentMessagesMap.get(keyStr);
-  }
-  shouldRecreateSession(jid, hasSession, errorCode) {
-    if (!hasSession) {
-      this.sessionRecreateHistory.set(jid, Date.now());
-      this.statistics.sessionRecreations++;
-      return {
-        reason: "we don't have a Signal session with them",
-        recreate: true
-      };
-    }
-    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 (!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
-    };
-  }
-  parseRetryErrorCode(errorAttr) {
-    if (errorAttr === undefined || errorAttr === '') {
-      return undefined;
-    }
-    const code = parseInt(errorAttr, 10);
-    if (Number.isNaN(code)) {
-      return undefined;
-    }
-    if (code >= RetryReason.UnknownError && code <= RetryReason.StatusRevokeDelay) {
-      return code;
-    }
-    return RetryReason.UnknownError;
-  }
-  isMacError(errorCode) {
-    return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
-  }
-  incrementRetryCount(messageId) {
-    this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
-    this.statistics.totalRetries++;
-    return this.retryCounters.get(messageId);
-  }
-  getRetryCount(messageId) {
-    return this.retryCounters.get(messageId) || 0;
-  }
-  hasExceededMaxRetries(messageId) {
-    return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
-  }
-  markRetrySuccess(messageId) {
-    this.statistics.successfulRetries++;
-    this.retryCounters.delete(messageId);
-    this.cancelPendingPhoneRequest(messageId);
-    this.removeRecentMessage(messageId);
-  }
-  markRetryFailed(messageId) {
-    this.statistics.failedRetries++;
-    this.retryCounters.delete(messageId);
-    this.cancelPendingPhoneRequest(messageId);
-    this.removeRecentMessage(messageId);
-  }
-  schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
-    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`);
-  }
-  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);
-  }
+        // 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