wowok 2.1.17 → 2.1.19

package/dist/cjs/w/messenger/messenger.js

@@ -17,33 +17,40 @@
 import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-import { CallProof } from "../call/proof.js";
-import { MessengerSession } from "./session.js";
+// eslint-disable-next-line import/no-cycle
+import { MessengerSession, DecryptionEngine } from "./session.js";
 import { MessengerServerClient } from "./server.js";
 import { MessageStorage, SessionStateStorage } from "./storage.js";
 import { hashPlaintext, verifyMessage, bytesToBase64 } from "./crypto.js";
 import { canonicalizeJson } from "./utils.js";
 import { DEFAULT_MESSENGER_CONFIG, MessengerError, MessengerErrorCode, MessageDirection, MessageStatus, WTS_FILE_BYTES_LIMIT, NORMAL_MESSAGE_BYTES_LIMIT, CHAIN_PROOF_TYPE, } from "./types.js";
 import { isValidWowAddress } from "../../utils/sui-types.js";
-import { Account } from "../local/account.js";
-import { EventSource as EventSourcePolyfill } from "eventsource";
-// Polyfill EventSource for Node.js environment
-if (typeof window === "undefined" &&
-    typeof globalThis.EventSource === "undefined") {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    globalThis.EventSource = EventSourcePolyfill;
-    console.log("[EventSource] Successfully polyfilled EventSource");
+// 动态获取 Account 实例的辅助函数
+async function getAccount() {
+    // eslint-disable-next-line import/no-cycle
+    const { Account } = await import("../local/account.js");
+    return Account.Instance();
 }
 export class Messenger {
     session;
     serverClient;
     config;
     userAddress = null;
-    eventSource = null;
     onMessageCallback = null;
-    prekeyCheckTimer = null;
+    pollingTimer = null;
+    messageConsecutiveEmptyPulls = 0;
+    prekeyConsecutiveOkCount = 0;
+    currentMessageInterval;
+    isPollingRunning = false;
     messageStorage;
     sessionStateStorage;
+    decryptionEngine;
+    // 【新增】等待解密的消息池（用于 Skip Keys 机制）
+    waitingMessages = new Map();
+    // 【新增】解密失败的消息（用于用户决策重发）
+    failedMessages = new Map();
+    // 【新增】重试计数器（3秒×3次机制）
+    waitingMessageRetries = new Map();
     constructor(userAddress, config) {
         this.userAddress = userAddress;
         this.config = { ...DEFAULT_MESSENGER_CONFIG, ...config };
@@ -51,6 +58,9 @@ export class Messenger {
         this.serverClient = new MessengerServerClient(this.config);
         this.messageStorage = new MessageStorage(userAddress);
         this.sessionStateStorage = new SessionStateStorage(userAddress);
+        this.decryptionEngine = new DecryptionEngine(this.session["store"]); // 使用 session 的 store
+        this.currentMessageInterval =
+            this.config.message_poll_default_interval_ms ?? 6 * 60 * 1000;
     }
     /**
      * 获取用户地址
@@ -70,7 +80,7 @@ export class Messenger {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        const account = await Account.Instance().get(this.userAddress, false);
+        const account = await (await getAccount()).get(this.userAddress, false);
         return account?.pubkey || "";
     }
     /**
@@ -93,7 +103,7 @@ export class Messenger {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        const account = await Account.Instance().get(this.userAddress, false);
+        const account = await (await getAccount()).get(this.userAddress, false);
         if (!account?.secret) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, `Account not found or no secret key for ${this.userAddress}`);
         }
@@ -126,20 +136,25 @@ export class Messenger {
      * 2. 注册设备到服务器
      * 3. 上传预密钥
      * 4. 检查预密钥状态（如低于阈值则补充）
-     * 5. 启动定期预密钥检查
+     * 5. 启动合并的polling timer
      */
     async initialize() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        // 确保身份并注册设备
+        // 确保身份
         await this.session.ensureIdentity(this.userAddress);
+        // 【更新】每次都注册/更新设备！
+        // Signal Protocol 最佳实践：每次初始化都可以更新预键
+        // - 已有会话不受影响（使用双棘轮动态密钥）
+        // - 新会话使用新的预键（确保本地和服务器一致）
+        //console.log(`[Messenger] Registering/updating device...`);
         await this.session.registerDevice(this.userAddress);
         await this.session.ensurePreKeys(this.userAddress);
         // 初始化时检查预密钥状态
         await this.checkAndRefillPrekeys();
-        // 启动定期预密钥检查
-        this.startPrekeyCheckTimer();
+        // 启动合并的polling timer
+        this.startPollingTimer();
     }
     /**
      * 检查并补充预密钥
@@ -153,26 +168,112 @@ export class Messenger {
         await this.session.ensurePreKeys(this.userAddress, false);
     }
     /**
-     * 启动预密钥定期检查定时器
+     * 启动合并的polling timer
      */
-    startPrekeyCheckTimer() {
-        if (this.prekeyCheckTimer) {
-            clearInterval(this.prekeyCheckTimer);
+    startPollingTimer() {
+        if (this.pollingTimer) {
+            clearTimeout(this.pollingTimer);
         }
-        const interval = this.config.prekeyCheckIntervalMs ?? 24 * 60 * 60 * 1000; // 默认1天
-        this.prekeyCheckTimer = setInterval(() => {
-            this.checkAndRefillPrekeys();
+        this.isPollingRunning = true;
+        this.scheduleNextPoll();
+    }
+    /**
+     * 停止polling timer
+     */
+    stopPollingTimer() {
+        this.isPollingRunning = false;
+        if (this.pollingTimer) {
+            clearTimeout(this.pollingTimer);
+            this.pollingTimer = null;
+        }
+    }
+    /**
+     * 安排下一次poll
+     */
+    scheduleNextPoll() {
+        if (!this.isPollingRunning)
+            return;
+        const interval = this.getNextPollInterval();
+        this.pollingTimer = setTimeout(() => {
+            this.poll()
+                .catch((error) => {
+                console.error("[Polling] Error during poll:", error);
+            })
+                .finally(() => {
+                this.scheduleNextPoll();
+            });
         }, interval);
-        //console.log(`Prekey check timer started (interval: ${interval}ms)`);
     }
     /**
-     * 停止预密钥定期检查定时器
+     * 获取下次poll的间隔时间
+     * 【优化】增加3秒快速模式（有待解密消息时）
+     */
+    getNextPollInterval() {
+        // 如果有等待解密的消息，使用3秒快速轮询
+        if (this.waitingMessages.size > 0) {
+            return this.config.message_poll_waiting_interval_ms ?? 3 * 1000;
+        }
+        return this.currentMessageInterval;
+    }
+    /**
+     * 执行一次poll（拉取消息和检查prekey状态）
+     */
+    async poll() {
+        if (!this.userAddress)
+            return;
+        try {
+            const response = await this.pullMessages();
+            // 处理消息
+            if (response.messages.length > 0) {
+                this.messageConsecutiveEmptyPulls = 0;
+                this.currentMessageInterval =
+                    this.config.message_poll_fast_interval_ms ?? 6 * 1000;
+                if (this.onMessageCallback) {
+                    this.onMessageCallback(response.messages);
+                }
+            }
+            else {
+                this.messageConsecutiveEmptyPulls++;
+                if (this.messageConsecutiveEmptyPulls >=
+                    (this.config.message_poll_consecutive_empty_limit ?? 3)) {
+                    this.currentMessageInterval =
+                        this.config.message_poll_default_interval_ms ??
+                            6 * 60 * 1000;
+                    this.messageConsecutiveEmptyPulls = 0;
+                }
+            }
+            // 处理prekey状态
+            if (response.prekey_status) {
+                const prekeyStatus = response.prekey_status;
+                if (prekeyStatus.shouldRefill) {
+                    this.prekeyConsecutiveOkCount = 0;
+                    await this.checkAndRefillPrekeys();
+                }
+                else {
+                    this.prekeyConsecutiveOkCount++;
+                    if (this.prekeyConsecutiveOkCount >=
+                        (this.config.prekey_poll_consecutive_ok_limit ?? 3)) {
+                        this.prekeyConsecutiveOkCount = 0;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error("[Polling] Poll error:", error);
+        }
+    }
+    /**
+     * 触发快速poll（发送消息后调用）
      */
-    stopPrekeyCheckTimer() {
-        if (this.prekeyCheckTimer) {
-            clearInterval(this.prekeyCheckTimer);
-            this.prekeyCheckTimer = null;
-            //console.log("Prekey check timer stopped");
+    triggerFastPoll() {
+        this.currentMessageInterval =
+            this.config.message_poll_fast_interval_ms ?? 6 * 1000;
+        this.messageConsecutiveEmptyPulls = 0;
+        if (this.isPollingRunning) {
+            if (this.pollingTimer) {
+                clearTimeout(this.pollingTimer);
+            }
+            this.scheduleNextPoll();
         }
     }
     /**
@@ -206,7 +307,7 @@ export class Messenger {
         const plaintextHash = hashPlaintext(plaintext, createdAt, options?.guardAddress, options?.passportAddress, lastReceivedLeafIndex);
         // 3. 签名消息
         // 注意: guard_address 和 passport_address 始终包含在签名中（可能为空字符串），防止参数篡改
-        const account = await Account.Instance().get(this.userAddress, false);
+        const account = await (await getAccount()).get(this.userAddress, false);
         if (!account) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User account not found");
         }
@@ -218,7 +319,7 @@ export class Messenger {
         const lastReceivedStr = lastReceivedLeafIndex >= 0 ? lastReceivedLeafIndex.toString() : "";
         const forceStr = options?.force ? "true" : "false";
         const signMessage = `send_message:${this.userAddress}:${recipientAddress}:${guardAddr}:${passportAddr}:${plaintextHash}:${lastReceivedStr}:${publicKey}:${timestamp}:${nonce}:${forceStr}`;
-        const signResult = await Account.Instance().signData(this.userAddress, signMessage);
+        const signResult = await (await getAccount()).signData(this.userAddress, signMessage);
         const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
         const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
         // 使用统一的 sendMessage API
@@ -296,6 +397,7 @@ export class Messenger {
                 }
             }
         }
+        this.triggerFastPoll();
         return {
             messageId: response.messageId,
             status: message.status,
@@ -321,9 +423,9 @@ export class Messenger {
         const timestamp = Date.now(); //@ 使用ms时间戳
         const nonce = this.generateNonce();
         const message = `fetch_messages:${this.userAddress}:${limit || 100}:${timestamp}:${nonce}`;
-        const account = await Account.Instance().get(this.userAddress, false);
+        const account = await (await getAccount()).get(this.userAddress, false);
         const publicKey = account?.pubkey || "";
-        const signResult = await Account.Instance().signData(this.userAddress, message);
+        const signResult = await (await getAccount()).signData(this.userAddress, message);
         const signature = Buffer.from(signResult.signature.slice(2), "hex");
         const signatureParams = {
             signatureScheme: "ED25519",
@@ -338,149 +440,81 @@ export class Messenger {
             console.log(`[Messenger] 消息 IDs: ${response.messages.map(m => m.id).join(', ')}`);
         }*/
         if (response.messages.length === 0) {
-            return [];
+            return {
+                messages: [],
+                prekey_status: response.prekey_status,
+            };
         }
         const decryptedMessages = [];
         const acknowledgedIds = [];
-        for (const serverMsg of response.messages) {
-            try {
-                //console.log(`[Messenger] 处理消息 ${serverMsg.id}, from=${serverMsg.from}, msgType=${serverMsg.msgType}`);
-                // 检查消息是否已经在本地存储
-                // 注意：由于每个用户有自己的数据库文件，消息 ID 不会冲突
-                const existingMessage = this.messageStorage.getMessage(serverMsg.id);
-                if (existingMessage) {
-                    // 消息已存在，直接确认
-                    //console.log(`[Messenger] 消息 ${serverMsg.id} 已存在于本地存储，跳过`);
-                    acknowledgedIds.push(serverMsg.id);
-                    continue;
-                }
-                // 2. 解密消息
-                //console.log(`[Messenger] 解密消息 ${serverMsg.id}...`);
-                const ciphertext = Uint8Array.from(Buffer.from(serverMsg.bodyB64, "base64"));
-                //console.log(`[Messenger] 密文长度: ${ciphertext.length} bytes`);
-                const decryptedData = await this.session.decryptMessage(this.userAddress, serverMsg.from, ciphertext.buffer, serverMsg.msgType);
-                //console.log(`[Messenger] 消息 ${serverMsg.id} 解密成功`);
-                // 【更新】明文直接就是消息内容（不再是 JSON 格式）
-                const plaintext = decryptedData;
-                // 【新增】从服务器返回的字段获取 lastReceivedLeafIndex
-                const senderLastReceivedIndex = serverMsg.lastReceivedLeafIndex ?? -1;
-                // 【新增】处理消息确认信息
-                if (senderLastReceivedIndex >= 0) {
-                    const myLastSent = this.getLastSentLeafIndex(serverMsg.from);
-                    if (senderLastReceivedIndex < myLastSent) {
-                        /*console.warn(
-                            `[Messenger] ${serverMsg.from} 可能丢失了消息，` +
-                                `对方确认: ${senderLastReceivedIndex}, ` +
-                                `我已发送: ${myLastSent}`,
-                        );*/
-                    }
-                }
-                // 3. 使用通用验证函数验证消息
-                // 检查必需字段
-                if (!serverMsg.clientTimestamp) {
-                    throw new Error(`Missing clientTimestamp for message ${serverMsg.id}`);
-                }
-                if (!serverMsg.plaintextHash) {
-                    throw new Error(`Missing plaintextHash for message ${serverMsg.id}`);
-                }
-                // 验证 Merkle 元数据完整性
-                if (serverMsg.merkleMetadata) {
-                    if (!serverMsg.merkleMetadata.prevRoot) {
-                        throw new Error(`Message ${serverMsg.id} missing prevRoot in merkleMetadata`);
-                    }
-                    if (!serverMsg.merkleMetadata.newRoot) {
-                        throw new Error(`Message ${serverMsg.id} missing newRoot in merkleMetadata`);
-                    }
-                }
-                const verificationResult = verifyMessage({
-                    messageId: serverMsg.id,
-                    plaintext,
-                    plaintextHash: serverMsg.plaintextHash,
-                    createdAt: serverMsg.clientTimestamp,
-                    guardAddress: serverMsg.guardAddress,
-                    passportAddress: serverMsg.passportAddress,
-                    lastReceivedLeafIndex: serverMsg.lastReceivedLeafIndex, // 【新增】传入消息确认字段
-                    serverSignature: serverMsg.merkleMetadata?.serverSignature,
-                    serverPublicKey: serverMsg.merkleMetadata?.serverPublicKey,
-                    merkleMetadata: serverMsg.merkleMetadata
-                        ? {
-                            prevRoot: serverMsg.merkleMetadata.prevRoot,
-                            newRoot: serverMsg.merkleMetadata.newRoot,
-                            serverTimestamp: serverMsg.merkleMetadata.serverTimestamp,
-                            leafIndex: serverMsg.merkleMetadata.leafIndex,
-                            proofSiblings: serverMsg.merkleMetadata.proofSiblings,
-                            proofIndices: serverMsg.merkleMetadata.proofIndices,
-                        }
-                        : undefined,
-                });
-                if (!verificationResult.valid) {
-                    throw new Error(verificationResult.error);
-                }
-                // 5. 保存到本地存储
-                // 经过 verifyMessage 验证，这些字段一定存在
-                const message = {
-                    messageId: serverMsg.id,
-                    fromAddress: serverMsg.from,
-                    toAddress: this.userAddress,
-                    plaintextHash: serverMsg.plaintextHash,
-                    plaintext,
-                    guardAddress: serverMsg.guardAddress,
-                    passportAddress: serverMsg.passportAddress,
-                    lastReceivedLeafIndex: serverMsg.lastReceivedLeafIndex, // 【新增】保存消息确认字段
-                    direction: MessageDirection.RECEIVED,
-                    status: MessageStatus.CONFIRMED,
-                    msgType: serverMsg.msgType,
-                    leafIndex: serverMsg.merkleMetadata?.leafIndex,
-                    prevRoot: serverMsg.merkleMetadata?.prevRoot,
-                    newRoot: serverMsg.merkleMetadata?.newRoot,
-                    serverSignature: serverMsg.merkleMetadata?.serverSignature,
-                    serverTimestamp: serverMsg.merkleMetadata?.serverTimestamp,
-                    serverPublicKey: serverMsg.merkleMetadata?.serverPublicKey,
-                    createdAt: serverMsg.clientTimestamp,
-                    // 保存 ZIP 元数据（如果是 ZIP 消息）
-                    zipMetadata: serverMsg.zipMetadata,
-                };
-                this.messageStorage.saveMessage(message);
-                // 更新会话状态
-                if (serverMsg.merkleMetadata) {
-                    this.sessionStateStorage.updateSessionState(this.userAddress, serverMsg.from, {
-                        currentRoot: serverMsg.merkleMetadata.newRoot,
-                        prevRoot: serverMsg.merkleMetadata.prevRoot,
-                        lastLeafIndex: serverMsg.merkleMetadata.leafIndex,
-                        lastSyncAt: Date.now(),
-                    });
-                }
-                const timestamp = serverMsg.merkleMetadata?.serverTimestamp ||
-                    serverMsg.clientTimestamp ||
-                    Date.now();
-                decryptedMessages.push({
-                    id: serverMsg.id,
-                    from: serverMsg.from,
-                    plaintext, // 【更新】明文直接是消息内容
-                    timestamp,
-                    merkleVerified: !!serverMsg.merkleMetadata,
-                    merkleData: serverMsg.merkleMetadata
-                        ? {
-                            leafIndex: serverMsg.merkleMetadata.leafIndex,
-                            rootHash: serverMsg.merkleMetadata.newRoot,
-                        }
-                        : undefined,
-                });
+        // 按 clientTimestamp 排序消息（发送方本地时间）
+        const sortedMessages = [...response.messages].sort(function (a, b) {
+            return (a.clientTimestamp || 0) - (b.clientTimestamp || 0);
+        });
+        // 【优化】首先尝试处理 waitingMessages 池中的消息
+        await this.processWaitingMessages(decryptedMessages, acknowledgedIds);
+        // 处理新拉取的消息（已排序）
+        for (const serverMsg of sortedMessages) {
+            // 检查是否已在 waitingMessages 池中
+            if (this.waitingMessages.has(serverMsg.id)) {
+                acknowledgedIds.push(serverMsg.id);
+                continue;
+            }
+            // 检查是否已在 failedMessages 中
+            if (this.failedMessages.has(serverMsg.id)) {
                 acknowledgedIds.push(serverMsg.id);
+                continue;
             }
-            catch (error) {
-                throw new Error(`Failed to decrypt message ${serverMsg.id}: ${error instanceof Error ? error.message : String(error)}`);
+            // 检查消息是否已经在本地存储
+            const existingMessage = this.messageStorage.getMessage(serverMsg.id);
+            if (existingMessage) {
+                // 消息已存在，直接确认
+                acknowledgedIds.push(serverMsg.id);
+                continue;
+            }
+            // 尝试解密消息
+            const decryptResult = await this.tryDecryptMessage(serverMsg);
+            if (decryptResult.success &&
+                decryptResult.message &&
+                decryptResult.decryptedData) {
+                // 解密成功，保存并添加到结果
+                this.messageStorage.saveMessage(decryptResult.message);
+                decryptedMessages.push(decryptResult.decryptedData);
+                acknowledgedIds.push(serverMsg.id);
+                // 从 waitingMessages 中移除（如果存在）
+                this.waitingMessages.delete(serverMsg.id);
             }
+            else if (decryptResult.shouldRetry) {
+                // 需要重试（Skip Keys 机制），加入等待池
+                console.warn(`[Messenger] 消息 ${serverMsg.id} 解密失败，加入等待池: ${decryptResult.error}`);
+                this.waitingMessages.set(serverMsg.id, serverMsg);
+                // 不解密成功，不加入 acknowledgedIds，下次继续尝试
+            }
+            else {
+                // 永久失败，保存失败状态
+                console.error(`[Messenger] 消息 ${serverMsg.id} 解密永久失败: ${decryptResult.error}`);
+                this.failedMessages.set(serverMsg.id, {
+                    message: serverMsg,
+                    error: decryptResult.error || "Unknown error",
+                });
+                // 保存失败状态到存储
+                await this.saveFailedMessage(serverMsg, decryptResult.error || "Unknown error");
+                acknowledgedIds.push(serverMsg.id);
+            }
+        }
+        // 【优化】重新调度轮询（如果有等待消息，会切换到3秒快速模式）
+        if (this.waitingMessages.size > 0 && this.isPollingRunning) {
+            this.reschedulePolling();
         }
         // 5. 确认已处理的消息（带签名）
         if (acknowledgedIds.length > 0 && this.userAddress) {
             const ackTimestamp = Date.now(); //@ 使用ms时间戳
             const ackNonce = this.generateNonce();
             // 签名消息格式: ack_messages:{user}:{message_ids}:{public_key}:{timestamp}:{nonce}
-            const account = await Account.Instance().get(this.userAddress, false);
+            const account = await (await getAccount()).get(this.userAddress, false);
             if (account?.pubkey) {
                 const ackMessage = `ack_messages:${this.userAddress}:${acknowledgedIds.join(",")}:${account.pubkey}:${ackTimestamp}:${ackNonce}`;
-                const signResult = await Account.Instance().signData(this.userAddress, ackMessage);
+                const signResult = await (await getAccount()).signData(this.userAddress, ackMessage);
                 const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
                 const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
                 await this.serverClient.acknowledgeMessages(acknowledgedIds, signResult.publicKey, {
@@ -492,9 +526,11 @@ export class Messenger {
                 });
             }
         }
-        // 6. 补充预密钥
-        await this.session.ensurePreKeys(this.userAddress);
-        return decryptedMessages;
+        // 6. 补充预密钥（poll方法会根据prekey_status来决定是否补充）
+        return {
+            messages: decryptedMessages,
+            prekey_status: response.prekey_status,
+        };
     }
     /**
      * 获取最后发送的消息序号
@@ -565,6 +601,7 @@ export class Messenger {
             timestamp: Date.now(),
         };
         // 使用 CallProof 提交到链上
+        const { CallProof } = await import("../call/proof.js");
         const callProof = new CallProof({
             proof: JSON.stringify(proofData),
             server_pubkey: serverPubKey,
@@ -585,281 +622,12 @@ export class Messenger {
             txHash: result?.digest || "",
         };
     }
-    /**
-     * 建立 SSE 连接并监听服务器事件
-     *
-     * 安全要求：必须提供签名验证，防止未授权监听他人事件
-     * @param onMessage 新消息回调
-     * @param signatureParams 签名参数（可选，不提供时自动生成）
-     */
-    async connectEventSource(onMessage, signatureParams) {
-        if (!this.userAddress) {
-            throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
-        }
-        // 关闭已有连接
-        this.disconnectEventSource();
-        if (onMessage) {
-            this.onMessageCallback = onMessage;
-        }
-        // 如果没有提供签名参数，自动生成
-        // 签名格式: event_stream:{address}:{timestamp}:{nonce}
-        const account = await Account.Instance().get(this.userAddress, false);
-        const publicKey = account?.pubkey || "";
-        let params = signatureParams;
-        if (!params) {
-            const timestamp = Date.now(); //@ 使用ms时间戳
-            const nonce = this.generateNonce();
-            const message = `event_stream:${this.userAddress}:${timestamp}:${nonce}`;
-            const signResult = await Account.Instance().signData(this.userAddress, message);
-            const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
-            const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
-            params = {
-                signatureScheme: "ED25519",
-                signature: signatureBase64,
-                timestamp,
-                nonce,
-            };
-        }
-        // 构建带签名的 URL
-        const queryParams = new URLSearchParams({
-            publicKey: publicKey,
-            signatureScheme: params.signatureScheme,
-            signature: params.signature,
-            timestamp: params.timestamp.toString(),
-            nonce: params.nonce,
-        });
-        const url = `${this.config.serverUrl}/v1/events/${this.userAddress}?${queryParams}`;
-        //console.log(`Connecting to SSE: ${url}`);
-        // 检查是否有 EventSource 可用
-        if (typeof EventSource === "undefined") {
-            console.warn("EventSource is not available in this environment. SSE functionality disabled, falling back to polling.");
-            return;
-        }
-        try {
-            this.eventSource = new EventSource(url);
-        }
-        catch (error) {
-            console.warn("Failed to create EventSource connection, falling back to polling.", error);
-            return;
-        }
-        // 监听消息事件
-        this.eventSource.onmessage = async (event) => {
-            try {
-                const sseEvent = JSON.parse(event.data);
-                //console.log("SSE event received:", sseEvent.type);
-                switch (sseEvent.type) {
-                    case "NewMessage":
-                        // 收到新消息通知，拉取并解密消息
-                        if (this.onMessageCallback) {
-                            const messages = await this.pullMessages();
-                            if (messages.length > 0) {
-                                this.onMessageCallback(messages);
-                            }
-                        }
-                        break;
-                    case "ark_confirmed": {
-                        // 发送方收到 ARK 确认，验证接收方签名后更新本地状态
-                        const { message_ids, recipient, recipient_public_key, signature, timestamp, } = sseEvent.data;
-                        /*console.log(
-                            `SSE ark_confirmed: messages ${message_ids} confirmed by ${recipient}`,
-                        );*/
-                        // 验证接收方签名（防止服务器作恶）
-                        // 签名消息格式: ack_messages:{recipient}:{message_ids}:{public_key}:{timestamp}:{nonce}
-                        // 注意: SSE事件中不包含nonce，因为nonce是在ARK请求时由接收方生成的，服务器只是转发
-                        const verifyMessage = `ack_messages:${recipient}:${message_ids.join(",")}:${recipient_public_key}:${timestamp}`;
-                        try {
-                            // 使用事件中携带的接收方公钥验证签名
-                            const { Ed25519PublicKey } = await import("../../keypairs/ed25519/publickey.js");
-                            const publicKey = new Ed25519PublicKey(recipient_public_key);
-                            const signatureBytes = Uint8Array.from(Buffer.from(signature, "base64"));
-                            const isValid = await publicKey.verify(new TextEncoder().encode(verifyMessage), signatureBytes);
-                            if (isValid) {
-                                // 签名验证成功，保存 ARK 确认（不可更改字段）
-                                for (const msgId of message_ids) {
-                                    // 获取现有消息并更新 ARK 确认
-                                    const existingMsg = this.messageStorage.getMessage(msgId);
-                                    if (existingMsg) {
-                                        existingMsg.arkConfirmed = {
-                                            recipient,
-                                            recipientPublicKey: recipient_public_key,
-                                            signature,
-                                            timestamp,
-                                        };
-                                        this.messageStorage.saveMessage(existingMsg);
-                                    }
-                                }
-                                /*console.log(
-                                    `ARK verified, stored ${message_ids.length} ARK confirmations`,
-                                );*/
-                            }
-                            else {
-                                console.error("ARK signature verification failed - possible server tampering");
-                            }
-                        }
-                        catch (error) {
-                            console.error("Failed to verify ARK signature:", error);
-                        }
-                        break;
-                    }
-                    case "PreKeyLow":
-                        // 收到预密钥低库存通知，立即补充
-                        /*console.log(
-                            `SSE PreKeyLow event: ${sseEvent.data.current}/${sseEvent.data.max_allowed}, auto-refilling...`,
-                        );*/
-                        await this.checkAndRefillPrekeys();
-                        break;
-                    case "Custom":
-                        // 自定义事件（如 Guard 确认/拒绝），暂不处理
-                        //console.log("SSE Custom event received");
-                        break;
-                    case "guard_confirmed": {
-                        // Guard 消息验证通过，更新消息的 merkleData
-                        const { message_id, merkle_data, timestamp: _timestamp, } = sseEvent.data;
-                        /*console.log(
-                            `SSE guard_confirmed: message ${message_id} confirmed`,
-                        );*/
-                        // 更新本地消息状态
-                        // 获取原始消息数据用于验证
-                        const existingMsg = this.messageStorage.getMessage(message_id);
-                        if (!existingMsg) {
-                            console.warn(`Guard confirmed event received but message ${message_id} not found in local storage`);
-                            break;
-                        }
-                        // 验证 Merkle 数据完整性
-                        if (!merkle_data.prevRoot) {
-                            console.error(`Guard message ${message_id} missing prevRoot in merkle_data`);
-                            break;
-                        }
-                        if (!merkle_data.newRoot) {
-                            console.error(`Guard message ${message_id} missing newRoot in merkle_data`);
-                            break;
-                        }
-                        if (!merkle_data.serverTimestamp) {
-                            console.error(`Guard message ${message_id} missing serverTimestamp in merkle_data`);
-                            break;
-                        }
-                        if (!merkle_data.serverSignature) {
-                            console.error(`Guard message ${message_id} missing serverSignature in merkle_data`);
-                            break;
-                        }
-                        if (!merkle_data.serverPublicKey) {
-                            console.error(`Guard message ${message_id} missing serverPublicKey in merkle_data`);
-                            break;
-                        }
-                        // 验证消息的 Merkle Root 计算
-                        const { verifySingleMerkleRoot } = await import("./crypto.js");
-                        const rootValid = verifySingleMerkleRoot(merkle_data.prevRoot, merkle_data.newRoot, existingMsg.plaintextHash, merkle_data.serverTimestamp, merkle_data.leafIndex);
-                        if (!rootValid.valid) {
-                            console.error(`Guard message ${message_id} Merkle root verification failed: ${rootValid.error}`);
-                            break;
-                        }
-                        // 验证服务器签名
-                        const { verifyEd25519Signature } = await import("./crypto.js");
-                        const signData = `${merkle_data.prevRoot}:${merkle_data.newRoot}:${merkle_data.serverTimestamp}:${merkle_data.serverPublicKey}`;
-                        const signatureValid = verifyEd25519Signature(merkle_data.serverPublicKey, signData, merkle_data.serverSignature);
-                        if (!signatureValid) {
-                            console.error(`Guard message ${message_id} server signature verification failed`);
-                            break;
-                        }
-                        /*console.log(
-                            `Guard message ${message_id} verification passed, updating...`,
-                        );*/
-                        // 直接使用 updateMessageStatus 更新消息的 Merkle 数据
-                        // 因为 message_id 已经包含 nonce，不需要再更新消息 ID
-                        this.messageStorage.updateMessageStatus(message_id, MessageStatus.CONFIRMED, {
-                            leafIndex: merkle_data.leafIndex,
-                            newRoot: merkle_data.newRoot,
-                            serverSignature: merkle_data.serverSignature,
-                            serverTimestamp: merkle_data.serverTimestamp,
-                            serverPublicKey: merkle_data.serverPublicKey,
-                        });
-                        const updated = true;
-                        if (updated) {
-                            /*console.log(
-                                `Guard message ${message_id} updated with merkle data`,
-                            );*/
-                            // 更新会话状态
-                            if (existingMsg.toAddress === null) {
-                                throw new Error(`Guard message ${message_id} has null toAddress`);
-                            }
-                            const toAddr = existingMsg.toAddress;
-                            if (toAddr === null) {
-                                throw new Error(`Guard message ${message_id} has null toAddress`);
-                            }
-                            this.sessionStateStorage.updateSessionState(this.userAddress, toAddr, {
-                                currentRoot: merkle_data.newRoot,
-                                prevRoot: merkle_data.prevRoot,
-                                lastLeafIndex: merkle_data.leafIndex,
-                                lastSyncAt: Date.now(),
-                            });
-                        }
-                        else {
-                            console.warn(`Failed to update Guard message ${message_id}`);
-                        }
-                        break;
-                    }
-                    case "guard_rejected": {
-                        // Guard 消息验证被拒绝
-                        const { message_id, reason: _reason, timestamp: _timestamp, } = sseEvent.data;
-                        /*console.log(
-                            `SSE guard_rejected: message ${message_id} rejected: ${reason}`,
-                        );*/
-                        // 更新本地消息状态
-                        // 首先尝试通过 message_id 查找消息
-                        const existingMsg = this.messageStorage.getMessage(message_id);
-                        if (existingMsg) {
-                            existingMsg.status = MessageStatus.REJECTED;
-                            this.messageStorage.saveMessage(existingMsg);
-                            /*console.log(
-                                `Guard message ${message_id} marked as rejected`,
-                            );*/
-                        }
-                        else {
-                            /*console.warn(
-                                `Guard rejected event received but message ${message_id} not found in local storage`,
-                            );*/
-                        }
-                        break;
-                    }
-                }
-            }
-            catch (error) {
-                console.error("Failed to handle SSE event:", error);
-            }
-        };
-        // 连接打开
-        this.eventSource.onopen = () => {
-            //console.log("SSE connection opened");
-        };
-        // 连接错误
-        this.eventSource.onerror = (error) => {
-            console.error("SSE connection error:", error);
-            this.disconnectEventSource();
-        };
-    }
-    /**
-     * 检查 SSE 是否已连接
-     */
-    isEventSourceConnected() {
-        return this.eventSource !== null;
-    }
-    /**
-     * 断开 SSE 连接
-     */
-    disconnectEventSource() {
-        if (this.eventSource) {
-            this.eventSource.close();
-            this.eventSource = null;
-            //console.log("SSE connection closed");
-        }
-    }
     /**
      * 销毁 Messenger 实例
-     * 清理所有资源（定时器、SSE 连接等）
+     * 清理所有资源（定时器等）
      */
     destroy() {
-        this.stopPrekeyCheckTimer();
-        this.disconnectEventSource();
+        this.stopPollingTimer();
         //console.log("Messenger instance destroyed");
     }
     /**
@@ -869,6 +637,13 @@ export class Messenger {
     disconnect() {
         this.destroy();
     }
+    /**
+     * 设置新消息回调
+     * @param onMessage 新消息回调函数
+     */
+    setOnMessageCallback(onMessage) {
+        this.onMessageCallback = onMessage;
+    }
     /**
      * 发送 ZIP 压缩文件
      *
@@ -922,7 +697,7 @@ export class Messenger {
         // 8. 发送到服务器（带 ZIP 元数据）
         const timestamp = Date.now();
         const nonce = this.generateNonce();
-        const account = await Account.Instance().get(this.userAddress, false);
+        const account = await (await getAccount()).get(this.userAddress, false);
         if (!account) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User account not found");
         }
@@ -932,7 +707,7 @@ export class Messenger {
         const lastReceivedStr = lastReceivedLeafIndex >= 0 ? lastReceivedLeafIndex.toString() : "";
         const forceStr = options?.force ? "true" : "false";
         const signMessage = `send_message:${this.userAddress}:${recipientAddress}:${guardAddr}:${passportAddr}:${plaintextHash}:${lastReceivedStr}:${publicKey}:${timestamp}:${nonce}:${forceStr}`;
-        const signResult = await Account.Instance().signData(this.userAddress, signMessage);
+        const signResult = await (await getAccount()).signData(this.userAddress, signMessage);
         const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
         const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
         // 使用统一的 sendMessage API
@@ -1013,6 +788,7 @@ export class Messenger {
                 }
             }
         }
+        this.triggerFastPoll();
         return {
             messageId: response.messageId,
             status: message.status,
@@ -1067,11 +843,11 @@ export class Messenger {
         const nonce = this.generateNonce();
         const dataJson = canonicalizeJson(data);
         const signMessage = `${timestamp}:${nonce}:${dataJson}`;
-        const signResult = await Account.Instance().signData(this.userAddress, signMessage);
+        const signResult = await (await getAccount()).signData(this.userAddress, signMessage);
         const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
         const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
         // 获取公钥（带标志位）用于服务器验证
-        const account = await Account.Instance().get(this.userAddress, false);
+        const account = await (await getAccount()).get(this.userAddress, false);
         if (!account || !account.pubkey) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "Account public key not found");
         }
@@ -1325,5 +1101,303 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest({});
         return this.serverClient.getGuardList(this.userAddress, signedRequest);
     }
+    // ========== 【新增】Skip Keys 和消息池相关方法 ==========
+    /**
+     * 尝试解密单条消息
+     * @param serverMsg 服务器消息
+     * @returns 解密结果
+     */
+    async tryDecryptMessage(serverMsg) {
+        try {
+            // 1. 使用新的解密引擎解密消息
+            const ciphertext = Uint8Array.from(Buffer.from(serverMsg.bodyB64, "base64"));
+            const decryptResult = await this.decryptionEngine.decryptMessage(this.userAddress, serverMsg.from, ciphertext.buffer, serverMsg.msgType);
+            if (!decryptResult.success) {
+                // 解密失败，判断是否应该重试
+                const shouldRetry = this.isRetryableError(decryptResult.error || "");
+                return {
+                    success: false,
+                    shouldRetry,
+                    error: decryptResult.error,
+                    sessionUpdated: decryptResult.sessionUpdated,
+                };
+            }
+            const plaintext = decryptResult.plaintext;
+            // 2. 验证消息
+            if (!serverMsg.clientTimestamp) {
+                throw new Error(`Missing clientTimestamp for message ${serverMsg.id}`);
+            }
+            if (!serverMsg.plaintextHash) {
+                throw new Error(`Missing plaintextHash for message ${serverMsg.id}`);
+            }
+            const verificationResult = verifyMessage({
+                messageId: serverMsg.id,
+                plaintext,
+                plaintextHash: serverMsg.plaintextHash,
+                createdAt: serverMsg.clientTimestamp,
+                guardAddress: serverMsg.guardAddress,
+                passportAddress: serverMsg.passportAddress,
+                lastReceivedLeafIndex: serverMsg.lastReceivedLeafIndex,
+                serverSignature: serverMsg.merkleMetadata?.serverSignature,
+                serverPublicKey: serverMsg.merkleMetadata?.serverPublicKey,
+                merkleMetadata: serverMsg.merkleMetadata
+                    ? {
+                        prevRoot: serverMsg.merkleMetadata.prevRoot,
+                        newRoot: serverMsg.merkleMetadata.newRoot,
+                        serverTimestamp: serverMsg.merkleMetadata.serverTimestamp,
+                        leafIndex: serverMsg.merkleMetadata.leafIndex,
+                        proofSiblings: serverMsg.merkleMetadata.proofSiblings,
+                        proofIndices: serverMsg.merkleMetadata.proofIndices,
+                    }
+                    : undefined,
+            });
+            if (!verificationResult.valid) {
+                throw new Error(verificationResult.error);
+            }
+            // 3. 构造消息对象
+            const message = {
+                messageId: serverMsg.id,
+                fromAddress: serverMsg.from,
+                toAddress: this.userAddress,
+                plaintextHash: serverMsg.plaintextHash,
+                plaintext,
+                guardAddress: serverMsg.guardAddress,
+                passportAddress: serverMsg.passportAddress,
+                lastReceivedLeafIndex: serverMsg.lastReceivedLeafIndex,
+                direction: MessageDirection.RECEIVED,
+                status: MessageStatus.DECRYPTED,
+                msgType: serverMsg.msgType,
+                leafIndex: serverMsg.merkleMetadata?.leafIndex,
+                prevRoot: serverMsg.merkleMetadata?.prevRoot,
+                newRoot: serverMsg.merkleMetadata?.newRoot,
+                serverSignature: serverMsg.merkleMetadata?.serverSignature,
+                serverTimestamp: serverMsg.merkleMetadata?.serverTimestamp,
+                serverPublicKey: serverMsg.merkleMetadata?.serverPublicKey,
+                createdAt: serverMsg.clientTimestamp,
+                receivedAt: Date.now(),
+                zipMetadata: serverMsg.zipMetadata,
+            };
+            // 4. 更新会话状态
+            if (serverMsg.merkleMetadata) {
+                this.sessionStateStorage.updateSessionState(this.userAddress, serverMsg.from, {
+                    currentRoot: serverMsg.merkleMetadata.newRoot,
+                    prevRoot: serverMsg.merkleMetadata.prevRoot,
+                    lastLeafIndex: serverMsg.merkleMetadata.leafIndex,
+                    lastSyncAt: Date.now(),
+                });
+            }
+            const timestamp = serverMsg.merkleMetadata?.serverTimestamp ||
+                serverMsg.clientTimestamp ||
+                Date.now();
+            // 【新增】根据收到的 lastReceivedLeafIndex，更新我发送的消息状态
+            if (serverMsg.lastReceivedLeafIndex !== undefined &&
+                serverMsg.lastReceivedLeafIndex >= 0) {
+                const mySentMessages = this.messageStorage
+                    .getMessagesBySession(this.userAddress, serverMsg.from)
+                    .filter((m) => m.direction === MessageDirection.SENT &&
+                    m.status === MessageStatus.CONFIRMED &&
+                    m.leafIndex !== undefined &&
+                    m.leafIndex <= serverMsg.lastReceivedLeafIndex);
+                for (const sentMsg of mySentMessages) {
+                    this.messageStorage.updateMessageStatus(sentMsg.messageId, MessageStatus.READ);
+                }
+            }
+            return {
+                success: true,
+                shouldRetry: false,
+                message,
+                decryptedData: {
+                    id: serverMsg.id,
+                    from: serverMsg.from,
+                    plaintext,
+                    timestamp,
+                    merkleVerified: !!serverMsg.merkleMetadata,
+                    merkleData: serverMsg.merkleMetadata
+                        ? {
+                            leafIndex: serverMsg.merkleMetadata.leafIndex,
+                            rootHash: serverMsg.merkleMetadata.newRoot,
+                        }
+                        : undefined,
+                },
+                sessionUpdated: decryptResult.sessionUpdated,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // 判断是否应该重试（Skip Keys 机制）
+            const shouldRetry = this.isRetryableError(errorMessage);
+            return {
+                success: false,
+                shouldRetry,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * 判断错误是否可重试（Skip Keys 机制）
+     * @param errorMessage 错误信息
+     * @returns 是否可重试
+     */
+    isRetryableError(errorMessage) {
+        // Signal Protocol 内部已经处理了 Skip Keys
+        // 这里的错误通常是更严重的错误
+        const retryablePatterns = [
+            /message number/i,
+            /chain key/i,
+            /session not found/i,
+            /prekey not found/i,
+            /PREKEY 竞争：我的地址较小，保留我的会话/i, // 【用户要求】处理 PREKEY 竞争情况
+            /The operation failed for an operation-specific reason/i, // 【新增】处理 DOMException 类型错误
+            /DOMException/i, // 【新增】处理 DOMException 类型错误
+            /收到 WHISPER_MESSAGE 但无现有会话，需要等待 PREKEY_MESSAGE/i, // 【新增】处理无会话但收到 WHISPER_MESSAGE 的情况
+        ];
+        return retryablePatterns.some((pattern) => pattern.test(errorMessage));
+    }
+    /**
+     * 处理 waitingMessages 池中的消息
+     * @param decryptedMessages 解密成功的消息列表
+     * @param acknowledgedIds 已确认的消息ID列表
+     */
+    async processWaitingMessages(decryptedMessages, acknowledgedIds) {
+        if (this.waitingMessages.size === 0)
+            return;
+        console.log(`[Messenger] 尝试处理 ${this.waitingMessages.size} 条等待消息`);
+        const processedIds = [];
+        // 对等待消息按 clientTimestamp 排序（发送方本地时间）
+        const sortedWaitingMsgs = Array.from(this.waitingMessages.values()).sort(function (a, b) {
+            return (a.clientTimestamp || 0) - (b.clientTimestamp || 0);
+        });
+        for (const serverMsg of sortedWaitingMsgs) {
+            const id = serverMsg.id;
+            const decryptResult = await this.tryDecryptMessage(serverMsg);
+            if (decryptResult.success &&
+                decryptResult.message &&
+                decryptResult.decryptedData) {
+                // 解密成功
+                this.messageStorage.saveMessage(decryptResult.message);
+                decryptedMessages.push(decryptResult.decryptedData);
+                acknowledgedIds.push(id);
+                processedIds.push(id);
+                // 清除重试计数
+                this.waitingMessageRetries.delete(id);
+            }
+            else if (!decryptResult.shouldRetry) {
+                // 永久失败
+                console.error(`[Messenger] 等待消息 ${id} 解密永久失败: ${decryptResult.error}`);
+                this.failedMessages.set(id, {
+                    message: serverMsg,
+                    error: decryptResult.error || "Unknown error",
+                });
+                await this.saveFailedMessage(serverMsg, decryptResult.error || "Unknown error");
+                acknowledgedIds.push(id);
+                processedIds.push(id);
+                // 清除重试计数
+                this.waitingMessageRetries.delete(id);
+            }
+            else {
+                // 需要重试，增加重试计数
+                const currentRetries = this.waitingMessageRetries.get(id) || 0;
+                const newRetries = currentRetries + 1;
+                if (newRetries >= 3) {
+                    // 超过3次重试，标记为永久失败
+                    console.error(`[Messenger] 等待消息 ${id} 重试3次后仍失败，标记为永久失败`);
+                    this.failedMessages.set(id, {
+                        message: serverMsg,
+                        error: decryptResult.error || "Retry limit exceeded",
+                    });
+                    await this.saveFailedMessage(serverMsg, decryptResult.error || "Retry limit exceeded");
+                    acknowledgedIds.push(id);
+                    processedIds.push(id);
+                    this.waitingMessageRetries.delete(id);
+                }
+                else {
+                    // 保留在 waitingMessages 中，等待下次重试
+                    this.waitingMessageRetries.set(id, newRetries);
+                    console.log(`[Messenger] 消息 ${id} 第 ${newRetries}/3 次重试失败，继续等待`);
+                }
+            }
+        }
+        // 从 waitingMessages 中移除已处理的消息
+        for (const id of processedIds) {
+            this.waitingMessages.delete(id);
+        }
+        if (processedIds.length > 0) {
+            console.log(`[Messenger] 成功处理 ${processedIds.length} 条等待消息`);
+        }
+    }
+    /**
+     * 保存解密失败的消息
+     * @param serverMsg 服务器消息
+     * @param error 错误信息
+     */
+    async saveFailedMessage(serverMsg, error) {
+        const failedMessage = {
+            messageId: serverMsg.id,
+            fromAddress: serverMsg.from,
+            toAddress: this.userAddress,
+            plaintextHash: serverMsg.plaintextHash || "",
+            guardAddress: serverMsg.guardAddress,
+            passportAddress: serverMsg.passportAddress,
+            lastReceivedLeafIndex: serverMsg.lastReceivedLeafIndex,
+            direction: MessageDirection.RECEIVED,
+            status: MessageStatus.DECRYPT_FAILED,
+            msgType: serverMsg.msgType,
+            leafIndex: serverMsg.merkleMetadata?.leafIndex,
+            prevRoot: serverMsg.merkleMetadata?.prevRoot,
+            newRoot: serverMsg.merkleMetadata?.newRoot,
+            serverSignature: serverMsg.merkleMetadata?.serverSignature,
+            serverTimestamp: serverMsg.merkleMetadata?.serverTimestamp,
+            serverPublicKey: serverMsg.merkleMetadata?.serverPublicKey,
+            createdAt: serverMsg.clientTimestamp || Date.now(),
+            receivedAt: Date.now(),
+            zipMetadata: serverMsg.zipMetadata,
+            decryptError: error,
+            decryptAttempts: 1,
+            lastDecryptAttemptAt: Date.now(),
+        };
+        this.messageStorage.saveMessage(failedMessage);
+    }
+    /**
+     * 重新调度轮询（用于切换到快速模式）
+     */
+    reschedulePolling() {
+        if (!this.isPollingRunning || !this.pollingTimer)
+            return;
+        console.log(`[Messenger] 重新调度轮询，切换到快速模式（等待消息: ${this.waitingMessages.size}）`);
+        clearTimeout(this.pollingTimer);
+        this.pollingTimer = null;
+        this.scheduleNextPoll();
+    }
+    /**
+     * 获取解密失败的消息（供用户决策重发）
+     * @returns 失败消息列表
+     */
+    getFailedMessages() {
+        return Array.from(this.failedMessages.entries()).map(([id, data]) => ({
+            messageId: id,
+            from: data.message.from,
+            error: data.error,
+            leafIndex: data.message.merkleMetadata?.leafIndex,
+        }));
+    }
+    /**
+     * 清除解密失败的消息记录
+     * @param messageId 消息ID（可选，不提供则清除所有）
+     */
+    clearFailedMessages(messageId) {
+        if (messageId) {
+            this.failedMessages.delete(messageId);
+        }
+        else {
+            this.failedMessages.clear();
+        }
+    }
+    /**
+     * 获取等待解密的消息数量
+     * @returns 等待消息数量
+     */
+    getWaitingMessageCount() {
+        return this.waitingMessages.size;
+    }
 }
 //# sourceMappingURL=messenger.js.map