@aseppxyzz12/baileys 1.1.8

package/lib/Utils/link-preview.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { unfurl: unfurl } = require("unfurl.js");
+const { prepareWAMessageMedia: prepareWAMessageMedia } = require("./messages");
+const {
+    getHttpStream: getHttpStream,
+    extractImageThumb: extractImageThumb,
+} = require("./messages-media");
+const THUMBNAIL_WIDTH_PX = 192;
+const getCompressedJpegThumbnail = async (
+    url,
+    { thumbnailWidth: thumbnailWidth, fetchOpts: fetchOpts }
+) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+const getUrlInfo = async (
+    text,
+    opts = { thumbnailWidth: THUMBNAIL_WIDTH_PX, fetchOpts: { timeout: 3e3 } }
+) => {
+    try {
+        let previewLink = text;
+        if (!text.startsWith("https://") && !text.startsWith("http://")) {
+            previewLink = "https://" + previewLink;
+        }
+        const { open_graph: info } = await unfurl(previewLink, {
+            ...opts.fetchOpts,
+            oembed: false,
+            compress: true,
+            size: 0,
+            follow: 50,
+        });
+        if (info && "title" in info && info.title) {
+            const image = info.images?.[0]?.url;
+            const urlInfo = {
+                "canonical-url": info.url,
+                "matched-text": text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image,
+            };
+            if (opts.uploadImage) {
+                const { imageMessage: 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;
+        }
+    }
+};
+module.exports = { getUrlInfo: getUrlInfo };

package/lib/Utils/logger.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino = require("pino");
+exports.default = pino({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { hkdf: hkdf } = require("./crypto");
+const o = 128;
+class LTHash {
+    constructor(e) {
+        this.salt = e;
+    }
+    async add(e, t) {
+        for (const item of t) {
+            e = await this._addSingle(e, item);
+        }
+        return e;
+    }
+    async subtract(e, t) {
+        for (const item of t) {
+            e = await this._subtractSingle(e, item);
+        }
+        return e;
+    }
+    async subtractThenAdd(e, addList, subtractList) {
+        const subtracted = await this.subtract(e, subtractList);
+        return this.add(subtracted, addList);
+    }
+    async _addSingle(e, t) {
+        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
+    }
+    async _subtractSingle(e, t) {
+        const derived = new Uint8Array(await hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
+    }
+    performPointwiseWithOverflow(e, t, op) {
+        const n = new DataView(e);
+        const i = new DataView(t);
+        const out = new ArrayBuffer(n.byteLength);
+        const s = new DataView(out);
+        for (let offset = 0; offset < n.byteLength; offset += 2) {
+            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
+        }
+        return out;
+    }
+}
+const LT_HASH_ANTI_TAMPERING = new LTHash("WhatsApp Patch Integrity");
+module.exports = { LT_HASH_ANTI_TAMPERING: LT_HASH_ANTI_TAMPERING };

package/lib/Utils/make-mutex.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { Mutex: AsyncMutex } = require("async-mutex");
+const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        },
+    };
+};
+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);
+                }
+            }
+        },
+    };
+};
+module.exports = { makeMutex: makeMutex, makeKeyedMutex: makeKeyedMutex };

package/lib/Utils/message-composer.js

@@ -0,0 +1,289 @@
+"use strict";
+// Ported & adapted from PouCode fork for AsepXyz Baileys
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRichMessageContent = exports.generateUnifiedResponseContent = exports.captureUnifiedResponse =
+    exports.generateCodeBlockContent = exports.generateListContent = exports.generateTableContent =
+    exports.buildBotForwardedMessage = exports.buildRichContextInfo = exports.tokenizeCode =
+    exports.RichSubMessageType = exports.CodeHighlightType = exports.LANGUAGE_KEYWORDS =
+    exports.PYTHON_KEYWORDS = exports.JS_KEYWORDS = void 0;
+const { generateMessageIDV2 } = require("./generics");
+
+const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as', 'const', 'let', 'var',
+    'function', 'class', 'extends', 'new', 'return', 'if', 'else', 'for',
+    'while', 'do', 'switch', 'case', 'break', 'continue', 'try', 'catch',
+    'finally', 'throw', 'async', 'await', 'yield', 'typeof', 'instanceof',
+    'in', 'of', 'delete', 'void', 'true', 'false', 'null', 'undefined',
+    'NaN', 'Infinity', 'this', 'super', 'static', 'get', 'set', 'debugger', 'with'
+]);
+exports.JS_KEYWORDS = JS_KEYWORDS;
+
+const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+]);
+exports.PYTHON_KEYWORDS = PYTHON_KEYWORDS;
+
+const LANGUAGE_KEYWORDS = {
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS
+};
+exports.LANGUAGE_KEYWORDS = LANGUAGE_KEYWORDS;
+
+var CodeHighlightType;
+(function (CodeHighlightType) {
+    CodeHighlightType[(CodeHighlightType['DEFAULT'] = 0)] = 'DEFAULT';
+    CodeHighlightType[(CodeHighlightType['KEYWORD'] = 1)] = 'KEYWORD';
+    CodeHighlightType[(CodeHighlightType['METHOD'] = 2)] = 'METHOD';
+    CodeHighlightType[(CodeHighlightType['STRING'] = 3)] = 'STRING';
+    CodeHighlightType[(CodeHighlightType['NUMBER'] = 4)] = 'NUMBER';
+    CodeHighlightType[(CodeHighlightType['COMMENT'] = 5)] = 'COMMENT';
+})(CodeHighlightType = exports.CodeHighlightType || (exports.CodeHighlightType = {}));
+
+var RichSubMessageType;
+(function (RichSubMessageType) {
+    RichSubMessageType[(RichSubMessageType['UNKNOWN'] = 0)] = 'UNKNOWN';
+    RichSubMessageType[(RichSubMessageType['GRID_IMAGE'] = 1)] = 'GRID_IMAGE';
+    RichSubMessageType[(RichSubMessageType['TEXT'] = 2)] = 'TEXT';
+    RichSubMessageType[(RichSubMessageType['INLINE_IMAGE'] = 3)] = 'INLINE_IMAGE';
+    RichSubMessageType[(RichSubMessageType['TABLE'] = 4)] = 'TABLE';
+    RichSubMessageType[(RichSubMessageType['CODE'] = 5)] = 'CODE';
+    RichSubMessageType[(RichSubMessageType['DYNAMIC'] = 6)] = 'DYNAMIC';
+    RichSubMessageType[(RichSubMessageType['MAP'] = 7)] = 'MAP';
+    RichSubMessageType[(RichSubMessageType['LATEX'] = 8)] = 'LATEX';
+    RichSubMessageType[(RichSubMessageType['CONTENT_ITEMS'] = 9)] = 'CONTENT_ITEMS';
+})(RichSubMessageType = exports.RichSubMessageType || (exports.RichSubMessageType = {}));
+
+const tokenizeCode = (codeStr, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || JS_KEYWORDS;
+    const blocks = [];
+    const lines = codeStr.split('\n');
+    for (let li = 0; li < lines.length; li++) {
+        const line = lines[li];
+        const isLast = li === lines.length - 1;
+        const nl = isLast ? '' : '\n';
+        if (!line.trim()) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl });
+            continue;
+        }
+        if (line.trim().startsWith('//') || line.trim().startsWith('#')) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: line + nl });
+            continue;
+        }
+        const regex = /(\/\/.*$|#.*$)|(["'`](?:[^"'`\\]|\\.)*["'`])|(\b\d+(?:\.\d+)?\b)|(\b[a-zA-Z_$][\w$]*\b)|([^\s\w$"'`]+)|(\s+)/g;
+        let match;
+        const tokens = [];
+        while ((match = regex.exec(line)) !== null) {
+            const val = match[0];
+            if (match[1]) {
+                tokens.push({ highlightType: CodeHighlightType.COMMENT, codeContent: val });
+            } else if (match[2]) {
+                tokens.push({ highlightType: CodeHighlightType.STRING, codeContent: val });
+            } else if (match[3]) {
+                tokens.push({ highlightType: CodeHighlightType.NUMBER, codeContent: val });
+            } else if (match[4]) {
+                if (keywords.has(val)) {
+                    tokens.push({ highlightType: CodeHighlightType.KEYWORD, codeContent: val });
+                } else {
+                    const after = line.slice(regex.lastIndex).trimStart();
+                    if (after.startsWith('(')) {
+                        tokens.push({ highlightType: CodeHighlightType.METHOD, codeContent: val });
+                    } else {
+                        tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val });
+                    }
+                }
+            } else {
+                tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val });
+            }
+        }
+        if (tokens.length === 0) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl });
+            continue;
+        }
+        const merged = [];
+        for (const t of tokens) {
+            const prev = merged.length > 0 ? merged[merged.length - 1] : undefined;
+            if (prev && prev.highlightType === t.highlightType) {
+                prev.codeContent += t.codeContent;
+            } else {
+                merged.push({ ...t });
+            }
+        }
+        if (merged.length > 0) {
+            merged[merged.length - 1].codeContent += nl;
+        }
+        blocks.push(...merged);
+    }
+    return blocks;
+};
+exports.tokenizeCode = tokenizeCode;
+
+const buildRichContextInfo = (quoted, options) => {
+    const ctxInfo = {
+        forwardingScore: 1,
+        isForwarded: true,
+        forwardedAiBotMessageInfo: { botJid: options?.botJid ? options.botJid : '867051314767696@bot' },
+        forwardOrigin: 4,
+        ...(options?.mentions ? { mentionedJid: options.mentions } : {})
+    };
+    if (quoted?.key) {
+        ctxInfo.stanzaId = quoted.key.id;
+        ctxInfo.participant = quoted.key.participant || quoted.sender || quoted.key.remoteJid;
+        ctxInfo.quotedMessage = quoted.message;
+    }
+    return ctxInfo;
+};
+exports.buildRichContextInfo = buildRichContextInfo;
+
+const buildBotForwardedMessage = (submessages, contextInfo, unifiedResponse) => {
+    const richResponse = { messageType: 1, submessages, contextInfo };
+    if (unifiedResponse) {
+        richResponse.unifiedResponse = unifiedResponse;
+    }
+    return {
+        botForwardedMessage: {
+            message: { richResponseMessage: richResponse }
+        }
+    };
+};
+exports.buildBotForwardedMessage = buildBotForwardedMessage;
+
+const generateTableContent = (title, headers, rows, quoted, options = {}) => {
+    const { footer, headerText } = options;
+    const tableRows = [{ items: headers, isHeading: true }, ...rows.map(row => ({ items: row.map(String) }))];
+    const submessages = [];
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText });
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } });
+    if (footer) submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateTableContent = generateTableContent;
+
+const generateListContent = (title, items, quoted, options = {}) => {
+    const { footer, headerText } = options;
+    const tableRows = items.map(item => ({
+        items: Array.isArray(item) ? item.map(String) : [String(item)]
+    }));
+    const submessages = [];
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText });
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } });
+    if (footer) submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateListContent = generateListContent;
+
+const generateCodeBlockContent = (code, quoted, options = {}) => {
+    const { title, footer, language = 'javascript' } = options;
+    const submessages = [];
+    if (title) submessages.push({ messageType: 2, messageText: title });
+    submessages.push({
+        messageType: 5,
+        codeMetadata: { codeLanguage: language, codeBlocks: tokenizeCode(code, language) }
+    });
+    if (footer) submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateCodeBlockContent = generateCodeBlockContent;
+
+const generateLatexContent = (quoted, options) => {
+    const { text, expressions, headerText, footer } = options;
+    const submessages = [];
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText });
+    const latexExpressions = expressions.map(expr => {
+        const entry = {
+            latexExpression: expr.latexExpression,
+            url: expr.url,
+            width: expr.width,
+            height: expr.height
+        };
+        if (expr.fontHeight !== undefined) entry.fontHeight = expr.fontHeight;
+        if (expr.imageTopPadding !== undefined) entry.imageTopPadding = expr.imageTopPadding;
+        if (expr.imageLeadingPadding !== undefined) entry.imageLeadingPadding = expr.imageLeadingPadding;
+        if (expr.imageBottomPadding !== undefined) entry.imageBottomPadding = expr.imageBottomPadding;
+        if (expr.imageTrailingPadding !== undefined) entry.imageTrailingPadding = expr.imageTrailingPadding;
+        return entry;
+    });
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } });
+    if (footer) submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateLatexContent = generateLatexContent;
+
+const generateLatexImageContent = async (quoted, options, uploadFn, renderLatexToPng) => {
+    const { text, expressions, headerText, footer } = options;
+    const submessages = [];
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText });
+    const latexExpressions = await Promise.all(
+        expressions.map(async expr => {
+            const { buffer, width, height } = await renderLatexToPng(expr.latexExpression);
+            const uploadResult = await uploadFn(buffer, 'image');
+            const imageUrl = uploadResult.url || uploadResult.directPath;
+            return { latexExpression: expr.latexExpression, url: imageUrl, width, height };
+        })
+    );
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } });
+    if (footer) submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateLatexImageContent = generateLatexImageContent;
+
+const generateLatexInlineImageContent = async (quoted, options, uploadFn, renderLatexToPng) => {
+    const { text, expressions, headerText, footer } = options;
+    const submessages = [];
+    if (headerText) submessages.push({ messageType: 2, messageText: headerText });
+    if (text) submessages.push({ messageType: 2, messageText: text });
+    for (const expr of expressions) {
+        const { buffer, width, height } = await renderLatexToPng(expr.latexExpression);
+        const uploadResult = await uploadFn(buffer, 'image');
+        const imageUrl = uploadResult.url || uploadResult.directPath;
+        submessages.push({
+            messageType: 3,
+            imageMetadata: {
+                imageUrl: { imagePreviewUrl: imageUrl, imageHighResUrl: imageUrl },
+                imageText: expr.latexExpression,
+                alignment: 2
+            }
+        });
+    }
+    if (footer) submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateLatexInlineImageContent = generateLatexInlineImageContent;
+
+const captureUnifiedResponse = msg => {
+    const botFwd = msg?.botForwardedMessage?.message;
+    if (!botFwd) return null;
+    const rich = botFwd.richResponseMessage;
+    if (!rich?.unifiedResponse?.data) return null;
+    return {
+        unifiedResponse: { data: rich.unifiedResponse.data },
+        submessages: rich.submessages || [],
+        contextInfo: rich.contextInfo || {}
+    };
+};
+exports.captureUnifiedResponse = captureUnifiedResponse;
+
+const generateUnifiedResponseContent = (quoted, captured) => {
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(captured.submessages, ctxInfo, captured.unifiedResponse), messageId: generateMessageIDV2() };
+};
+exports.generateUnifiedResponseContent = generateUnifiedResponseContent;
+
+const generateRichMessageContent = (submessages, quoted, options) => {
+    const ctxInfo = buildRichContextInfo(quoted, options);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: generateMessageIDV2() };
+};
+exports.generateRichMessageContent = generateRichMessageContent;

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { LRUCache: LRUCache } = require("lru-cache");
+const RECENT_MESSAGES_SIZE = 512;
+const MESSAGE_KEY_SEPARATOR = "\0";
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1e3;
+const PHONE_REQUEST_DELAY = 3e3;
+class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger;
+        this.recentMessagesMap = new LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1e3,
+            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 * 1e3,
+            ttlAutopurge: true,
+            updateAgeOnGet: 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: to, id: id };
+        const keyStr = this.keyToString(key);
+        this.recentMessagesMap.set(keyStr, {
+            message: 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: to, id: id };
+        const keyStr = this.keyToString(key);
+        return this.recentMessagesMap.get(keyStr);
+    }
+    shouldRecreateSession(jid, retryCount, hasSession) {
+        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 (retryCount < 2) {
+            return { reason: "", recreate: false };
+        }
+        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 };
+    }
+    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}`);
+        }
+    }
+    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);
+    }
+}
+module.exports = { MessageRetryManager: MessageRetryManager };