wowok 2.1.38 → 2.1.40

package/dist/esm/w/messenger/messenger.js

@@ -1,23 +1,6 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Messenger 核心模块
- *
- * 提供完整的端到端加密消息功能：
- * 1. 发送加密消息（集成 Merkle Tree 时序证明）
- * 2. 接收并解密消息
- * 3. 链上证明提交（使用 proof.ts）
- * 4. 会话状态同步
- *
- * 三重信任模型：
- * - 身份信任：wowok 账户 Ed25519 签名
- * - 加密信任：Signal Protocol 双棘轮
- * - 时序信任：Merkle Tree + 服务器签名 + 链上证明
- */
 import { createHash } from "crypto";
 import * as fs from "fs";
 import * as path from "path";
-// eslint-disable-next-line import/no-cycle
 import { MessengerSession, DecryptionEngine } from "./session.js";
 import { MessengerServerClient } from "./server.js";
 import { MessageStorage, SessionStateStorage } from "./storage.js";
@@ -25,9 +8,7 @@ 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";
-// 动态获取 Account 实例的辅助函数
 async function getAccount() {
-    // eslint-disable-next-line import/no-cycle
     const { Account } = await import("../local/account.js");
     return Account.Instance();
 }
@@ -45,11 +26,8 @@ export class Messenger {
     messageStorage;
     sessionStateStorage;
     decryptionEngine;
-    // 【新增】等待解密的消息池（用于 Skip Keys 机制）
     waitingMessages = new Map();
-    // 【新增】解密失败的消息（用于用户决策重发）
     failedMessages = new Map();
-    // 【新增】重试计数器（3秒×3次机制）
     waitingMessageRetries = new Map();
     constructor(userAddress, config) {
         this.userAddress = userAddress;
@@ -58,24 +36,16 @@ 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.decryptionEngine = new DecryptionEngine(this.session["store"]);
         this.currentMessageInterval =
             this.config.message_poll_default_interval_ms ?? 6 * 60 * 1000;
     }
-    /**
-     * 获取用户地址
-     * @returns 用户地址
-     */
     getUserAddress() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
         return this.userAddress;
     }
-    /**
-     * 获取用户公钥
-     * @returns 公钥（带标志位）
-     */
     async getPublicKey() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -83,22 +53,12 @@ export class Messenger {
         const account = await (await getAccount()).get(this.userAddress, false);
         return account?.pubkey || "";
     }
-    /**
-     * 验证Guard消息格式
-     * @param guardAddress Guard地址
-     * @param passportAddress Passport地址
-     * @returns 是否为有效的Guard消息
-     */
     isValidGuardMessage(guardAddress, passportAddress) {
         return Boolean(guardAddress &&
             passportAddress &&
             isValidWowAddress(guardAddress) &&
             isValidWowAddress(passportAddress));
     }
-    /**
-     * 生成签名参数
-     * 用于需要签名验证的 API 调用
-     */
     async generateSignatureParams(operation) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -111,7 +71,7 @@ export class Messenger {
         const keypair = Ed25519Keypair.fromSecretKey(account.secret);
         const publicKey = keypair.getPublicKey();
         const publicKeyWithFlag = publicKey.toWPublicKey();
-        const timestamp = Date.now(); //@ 使用ms时间戳
+        const timestamp = Date.now();
         const nonce = this.generateNonce();
         const message = `${operation}:${publicKeyWithFlag}:${timestamp}:${nonce}`;
         const signature = await keypair.sign(new TextEncoder().encode(message));
@@ -122,54 +82,26 @@ export class Messenger {
             nonce,
         };
     }
-    /**
-     * 生成随机 nonce
-     */
     generateNonce() {
         const array = new Uint8Array(16);
         crypto.getRandomValues(array);
         return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
     }
-    /**
-     * 初始化 Messenger
-     * 1. 确保本地身份
-     * 2. 注册设备到服务器
-     * 3. 上传预密钥
-     * 4. 检查预密钥状态（如低于阈值则补充）
-     * 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();
-        // 启动合并的polling timer
         this.startPollingTimer();
     }
-    /**
-     * 检查并补充预密钥
-     *
-     * 逻辑：如果服务器预密钥未满，自动补充到最大容量
-     */
     async checkAndRefillPrekeys() {
         if (!this.userAddress)
             return;
-        // 直接调用 ensurePreKeys，它会查询服务器状态并按需补充
         await this.session.ensurePreKeys(this.userAddress, false);
     }
-    /**
-     * 启动合并的polling timer
-     */
     startPollingTimer() {
         if (this.pollingTimer) {
             clearTimeout(this.pollingTimer);
@@ -177,9 +109,6 @@ export class Messenger {
         this.isPollingRunning = true;
         this.scheduleNextPoll();
     }
-    /**
-     * 停止polling timer
-     */
     stopPollingTimer() {
         this.isPollingRunning = false;
         if (this.pollingTimer) {
@@ -187,9 +116,6 @@ export class Messenger {
             this.pollingTimer = null;
         }
     }
-    /**
-     * 安排下一次poll
-     */
     scheduleNextPoll() {
         if (!this.isPollingRunning)
             return;
@@ -204,26 +130,17 @@ export class Messenger {
             });
         }, interval);
     }
-    /**
-     * 获取下次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 =
@@ -242,7 +159,6 @@ export class Messenger {
                     this.messageConsecutiveEmptyPulls = 0;
                 }
             }
-            // 处理prekey状态
             if (response.prekey_status) {
                 const prekeyStatus = response.prekey_status;
                 if (prekeyStatus.shouldRefill) {
@@ -262,9 +178,6 @@ export class Messenger {
             console.error("[Polling] Poll error:", error);
         }
     }
-    /**
-     * 触发快速poll（发送消息后调用）
-     */
     triggerFastPoll() {
         this.currentMessageInterval =
             this.config.message_poll_fast_interval_ms ?? 6 * 1000;
@@ -276,15 +189,6 @@ export class Messenger {
             this.scheduleNextPoll();
         }
     }
-    /**
-     * 发送加密消息
-     *
-     * 流程：
-     * 1. 使用 Signal Protocol 加密消息
-     * 2. 发送到服务器
-     * 3. 接收服务器返回的 Merkle 证明数据
-     * 4. 本地存储消息
-     */
     async sendMessage(recipientAddress, plaintext, options) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -292,24 +196,15 @@ export class Messenger {
         const createdAt = Date.now();
         const timestamp = Date.now();
         const nonce = this.generateNonce();
-        // 检查普通消息大小限制（10KB）
         const plaintextBytes = new TextEncoder().encode(plaintext).length;
         if (plaintextBytes > NORMAL_MESSAGE_BYTES_LIMIT) {
             throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message size (${plaintextBytes} bytes) exceeds maximum allowed size (${NORMAL_MESSAGE_BYTES_LIMIT} bytes). Consider using sendZipFile for large content.`);
         }
-        // 【关键修复】发送前先拉取对方发送的最新消息
-        // 确保 lastReceivedLeafIndex 包含所有已解密的消息
         await this.pullMessages();
-        // 【新增】获取最后收到的消息序号（用于消息确认）
         const lastReceivedLeafIndex = this.messageStorage.getLastReceivedLeafIndex(this.userAddress, recipientAddress);
-        // 1. 加密消息（明文就是原始消息内容）
         const encrypted = await this.session.encryptMessage(this.userAddress, recipientAddress, plaintext);
         const ciphertext = Buffer.from(new Uint8Array(encrypted.body)).toString("base64");
-        // 2. 计算明文哈希（用于 Merkle Tree 证明）
-        // 【更新】包含 lastReceivedLeafIndex 在哈希计算中
         const plaintextHash = hashPlaintext(plaintext, createdAt, options?.guardAddress, options?.passportAddress, lastReceivedLeafIndex);
-        // 3. 签名消息
-        // 注意: guard_address 和 passport_address 始终包含在签名中（可能为空字符串），防止参数篡改
         const account = await (await getAccount()).get(this.userAddress, false);
         if (!account) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User account not found");
@@ -317,15 +212,12 @@ export class Messenger {
         const publicKey = account.pubkey;
         const guardAddr = options?.guardAddress || "";
         const passportAddr = options?.passportAddress || "";
-        // 统一发送模式（合并 send 和 send_force）
-        // 统一签名格式: send_message:{sender}:{recipient}:{guard_address}:{passport_address}:{plaintext_hash}:{last_received_leaf_index}:{public_key}:{timestamp}:{nonce}:{force}
         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 (await getAccount()).signData(this.userAddress, signMessage);
         const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
         const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
-        // 使用统一的 sendMessage API
         const response = await this.serverClient.sendMessage({
             sender: signResult.publicKey,
             recipient: recipientAddress,
@@ -340,12 +232,10 @@ export class Messenger {
             guardAddress: options?.guardAddress,
             passportAddress: options?.passportAddress,
             force: options?.force,
-            // 【修复】只有当 lastReceivedLeafIndex >= 0 时才发送，否则发送 undefined
             lastReceivedLeafIndex: lastReceivedLeafIndex >= 0
                 ? lastReceivedLeafIndex
                 : undefined,
         });
-        // 4. 保存到本地存储
         const message = {
             messageId: response.messageId,
             fromAddress: this.userAddress,
@@ -354,7 +244,7 @@ export class Messenger {
             plaintext,
             guardAddress: options?.guardAddress,
             passportAddress: options?.passportAddress,
-            lastReceivedLeafIndex, // 【新增】保存消息确认字段
+            lastReceivedLeafIndex,
             direction: MessageDirection.SENT,
             status: response.status === "confirmed"
                 ? MessageStatus.CONFIRMED
@@ -369,7 +259,6 @@ export class Messenger {
             message.serverSignature = response.merkleData.serverSignature;
             message.serverTimestamp = response.merkleData.serverTimestamp;
             message.serverPublicKey = response.merkleData.serverPublicKey;
-            // 更新会话状态
             this.sessionStateStorage.updateSessionState(this.userAddress, recipientAddress, {
                 currentRoot: response.merkleData.newRoot,
                 prevRoot: response.merkleData.prevRoot,
@@ -378,15 +267,11 @@ export class Messenger {
             });
         }
         this.messageStorage.saveMessage(message);
-        // 方案B：处理服务器返回的其他已验证消息的 Merkle 数据
-        // 这些消息可能之前因为发送方离线而没有收到 Merkle 数据
         if (response.pendingMerkleData) {
             for (const [msgId, merkleData] of Object.entries(response.pendingMerkleData)) {
-                // 检查本地是否已有该消息
                 const existingMsg = this.messageStorage.getMessage(msgId);
                 if (existingMsg &&
                     existingMsg.status === MessageStatus.PENDING) {
-                    // 更新消息的 Merkle 数据
                     this.messageStorage.updateMessageStatus(msgId, MessageStatus.CONFIRMED, {
                         leafIndex: merkleData.leafIndex,
                         newRoot: merkleData.newRoot,
@@ -394,9 +279,6 @@ export class Messenger {
                         serverTimestamp: merkleData.serverTimestamp,
                         serverPublicKey: merkleData.serverPublicKey,
                     });
-                    /*console.log(
-                        `Updated pending message ${msgId} with merkle data from pendingMerkleData`,
-                    );*/
                 }
             }
         }
@@ -409,22 +291,11 @@ export class Messenger {
             lastReceivedLeafIndex: lastReceivedLeafIndex >= 0 ? lastReceivedLeafIndex : undefined,
         };
     }
-    /**
-     * 拉取消息
-     *
-     * 流程：
-     * 1. 从服务器拉取消息
-     * 2. 解密消息（Signal Protocol）
-     * 3. 验证 Merkle 证明
-     * 4. 本地存储并确认消息
-     */
     async pullMessages(limit) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        // 1. 生成签名参数
-        // 签名格式: fetch_messages:{address}:{limit}:{timestamp}:{nonce}
-        const timestamp = Date.now(); //@ 使用ms时间戳
+        const timestamp = Date.now();
         const nonce = this.generateNonce();
         const message = `fetch_messages:${this.userAddress}:${limit || 100}:${timestamp}:${nonce}`;
         const account = await (await getAccount()).get(this.userAddress, false);
@@ -437,12 +308,7 @@ export class Messenger {
             timestamp,
             nonce,
         };
-        // 2. 拉取消息（带签名验证）
         const response = await this.serverClient.pullMessages(this.userAddress, publicKey, signatureParams, limit);
-        /*console.log(`[Messenger] 服务器返回 ${response.messages.length} 条消息`);
-        if (response.messages.length > 0) {
-            console.log(`[Messenger] 消息 IDs: ${response.messages.map(m => m.id).join(', ')}`);
-        }*/
         if (response.messages.length === 0) {
             return {
                 messages: [],
@@ -451,70 +317,53 @@ export class Messenger {
         }
         const decryptedMessages = [];
         const acknowledgedIds = [];
-        // 按 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;
             }
-            // 检查消息是否已经在本地存储
             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 ackTimestamp = Date.now();
             const ackNonce = this.generateNonce();
-            // 签名消息格式: ack_messages:{user}:{message_ids}:{public_key}:{timestamp}:{nonce}
             const account = await (await getAccount()).get(this.userAddress, false);
             if (account?.pubkey) {
                 const ackMessage = `ack_messages:${this.userAddress}:${acknowledgedIds.join(",")}:${account.pubkey}:${ackTimestamp}:${ackNonce}`;
@@ -530,17 +379,11 @@ export class Messenger {
                 });
             }
         }
-        // 6. 补充预密钥（poll方法会根据prekey_status来决定是否补充）
         return {
             messages: decryptedMessages,
             prekey_status: response.prekey_status,
         };
     }
-    /**
-     * 获取最后发送的消息序号
-     * @param peerAddress 对方地址
-     * @returns 最后发送的消息 leafIndex，如果没有发送过返回 -1
-     */
     getLastSentLeafIndex(peerAddress) {
         if (!this.userAddress)
             return -1;
@@ -551,43 +394,26 @@ export class Messenger {
             return -1;
         return Math.max(...sentMessages.map((m) => m.leafIndex));
     }
-    /**
-     * 获取会话历史消息
-     */
     getSessionMessages(peerAddress) {
         if (!this.userAddress) {
             return [];
         }
         return this.messageStorage.getMessagesBySession(this.userAddress, peerAddress);
     }
-    /**
-     * 获取会话当前状态
-     */
     getSessionState(peerAddress) {
         if (!this.userAddress) {
             return undefined;
         }
         return this.sessionStateStorage.getSessionState(this.userAddress, peerAddress);
     }
-    /**
-     * 提交链上证明
-     *
-     * 使用 proof.ts 将 Merkle Root 提交到链上，获得时间证明
-     *
-     * @param env CallEnv 环境
-     * @param peerAddress 对方地址
-     * @param description 证明描述
-     */
     async submitChainProof(env, peerAddress, description) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        // 获取当前会话状态
         const sessionState = this.sessionStateStorage.getSessionState(this.userAddress, peerAddress);
         if (!sessionState || !sessionState.currentRoot) {
             throw new MessengerError(MessengerErrorCode.SESSION_NOT_ESTABLISHED, "No session state found");
         }
-        // 从会话消息中获取服务器公钥和签名
         const messages = this.messageStorage.getMessagesBySession(this.userAddress, peerAddress);
         const lastMessage = messages[messages.length - 1];
         if (!lastMessage ||
@@ -597,28 +423,24 @@ export class Messenger {
         }
         const serverPubKey = lastMessage.serverPublicKey;
         const serverSignature = lastMessage.serverSignature;
-        // 构造证明数据
         const proofData = {
             sessionId: sessionState.sessionId,
             merkleRoot: sessionState.currentRoot,
             messageCount: sessionState.messageCount,
             timestamp: Date.now(),
         };
-        // 使用 CallProof 提交到链上
         const { CallProof } = await import("../call/proof.js");
         const callProof = new CallProof({
             proof: JSON.stringify(proofData),
             server_pubkey: serverPubKey,
             server_signature: serverSignature,
-            proof_type: CHAIN_PROOF_TYPE, // 1 = Messenger Session Proof
+            proof_type: CHAIN_PROOF_TYPE,
             description: description ||
                 `Messenger session proof for ${this.userAddress} <-> ${peerAddress}`,
             item_count: sessionState.messageCount,
             about_address: sessionState.sessionId,
         });
         const result = await callProof.call(env);
-        // 从结果中提取 proof 对象地址
-        // 这里需要根据实际的 CallProof 返回格式调整
         const responseData = result?.objectChanges;
         const proofAddress = responseData?.find((change) => change.objectType?.includes("Proof"))?.objectId;
         return {
@@ -626,46 +448,20 @@ export class Messenger {
             txHash: result?.digest || "",
         };
     }
-    /**
-     * 销毁 Messenger 实例
-     * 清理所有资源（定时器等）
-     */
     destroy() {
         this.stopPollingTimer();
-        //console.log("Messenger instance destroyed");
     }
-    /**
-     * 断开连接（destroy 的别名）
-     * 用于清理资源
-     */
     disconnect() {
         this.destroy();
     }
-    /**
-     * 设置新消息回调
-     * @param onMessage 新消息回调函数
-     */
     setOnMessageCallback(onMessage) {
         this.onMessageCallback = onMessage;
     }
-    /**
-     * 发送 ZIP 压缩文件
-     *
-     * 支持发送本地或网络 WTS/WIP 文件，经过 ZIP 压缩后发送给对方
-     * 支持 Guard 验证，如果提供 guardAddress 和 passportAddress，消息将进入 Guard 验证流程
-     *
-     * @param recipientAddress 接收方地址
-     * @param source 文件源（本地路径或网络 URL）
-     * @param options 可选参数
-     * @returns 发送结果
-     */
     async sendZipFile(recipientAddress, source, options) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        // 1. 加载文件内容
         const fileData = await this.loadFileData(source);
-        // 2. 创建 ZIP 压缩
         const { ZipWriter, BlobWriter, Uint8ArrayReader } = await import("@zip.js/zip.js");
         const fileName = options?.fileName || path.basename(source) || "file.zip";
         const contentType = options?.contentType || this.detectContentType(fileName);
@@ -675,36 +471,25 @@ export class Messenger {
         await zipWriter.close();
         const zipFileBlob = await zipFileWriter.getData();
         const zipBlob = new Uint8Array(await zipFileBlob.arrayBuffer());
-        // 3. 本地文件大小限制检查（默认 5MB）
         if (zipBlob.length > WTS_FILE_BYTES_LIMIT) {
             throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `ZIP file size (${zipBlob.length} bytes) exceeds local maximum allowed size (${WTS_FILE_BYTES_LIMIT} bytes)`);
         }
-        // 4. 计算 ZIP 文件哈希（用于 zipMetadata）
         const zipFileHash = "0x" + createHash("sha256").update(zipBlob).digest("hex");
-        // 4. 将 ZIP 数据转为 base64
         const zipBase64 = Buffer.from(zipBlob).toString("base64");
-        // 5. 构造 ZIP 元数据
         const zipMetadata = {
             fileName: `${fileName}.zip`,
             fileSize: zipBlob.length,
             fileHash: zipFileHash,
             contentType: contentType,
         };
-        // 【关键修复】发送前先拉取对方发送的最新消息
-        // 确保 lastReceivedLeafIndex 包含所有已解密的消息
         await this.pullMessages();
-        // 【新增】获取最后收到的消息序号
         const lastReceivedLeafIndex = this.messageStorage.getLastReceivedLeafIndex(this.userAddress, recipientAddress);
-        // 6. 加密 ZIP 数据（作为普通消息发送，明文就是 ZIP 的 base64）
         const createdAt = Date.now();
         const encrypted = await this.session.encryptMessage(this.userAddress, recipientAddress, zipBase64);
         const ciphertext = Buffer.from(new Uint8Array(encrypted.body)).toString("base64");
-        // 7. 计算 plaintextHash（使用与服务器一致的格式）
-        // 【更新】包含 lastReceivedLeafIndex 在哈希计算中
         const guardAddr = options?.guardAddress || "";
         const passportAddr = options?.passportAddress || "";
         const plaintextHash = hashPlaintext(zipBase64, createdAt, guardAddr, passportAddr, lastReceivedLeafIndex);
-        // 8. 发送到服务器（带 ZIP 元数据）
         const timestamp = Date.now();
         const nonce = this.generateNonce();
         const account = await (await getAccount()).get(this.userAddress, false);
@@ -712,27 +497,23 @@ export class Messenger {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User account not found");
         }
         const publicKey = account.pubkey;
-        // 统一发送模式（合并 send 和 send_force）
-        // 统一签名格式: send_message:{sender}:{recipient}:{guard_address}:{passport_address}:{plaintext_hash}:{last_received_leaf_index}:{public_key}:{timestamp}:{nonce}:{force}
         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 (await getAccount()).signData(this.userAddress, signMessage);
         const signatureBuffer = Buffer.from(signResult.signature.slice(2), "hex");
         const signatureBase64 = bytesToBase64(new Uint8Array(signatureBuffer));
-        // 使用统一的 sendMessage API
         const response = await this.serverClient.sendMessage({
             sender: signResult.publicKey,
             recipient: recipientAddress,
             ciphertext,
             plaintextHash,
             clientTimestamp: createdAt,
-            msgType: encrypted.type, // 使用底层 Signal Protocol 消息类型（1 或 3）
+            msgType: encrypted.type,
             zipMetadata,
             guardAddress: options?.guardAddress,
             passportAddress: options?.passportAddress,
             force: options?.force,
-            // 【修复】只有当 lastReceivedLeafIndex >= 0 时才发送，否则发送 undefined
             lastReceivedLeafIndex: lastReceivedLeafIndex >= 0
                 ? lastReceivedLeafIndex
                 : undefined,
@@ -741,22 +522,20 @@ export class Messenger {
             timestamp,
             nonce,
         });
-        // 9. 保存到本地存储
-        // 使用底层 Signal Protocol 消息类型（1 或 3），通过 zipMetadata 标识这是 ZIP 文件
         const message = {
             messageId: response.messageId,
             fromAddress: this.userAddress,
             toAddress: recipientAddress,
             plaintextHash,
-            plaintext: zipBase64, // 保存 ZIP 数据的 base64 编码，方便本地查看
+            plaintext: zipBase64,
             guardAddress: options?.guardAddress,
             passportAddress: options?.passportAddress,
-            lastReceivedLeafIndex, // 【新增】保存消息确认字段
+            lastReceivedLeafIndex,
             direction: MessageDirection.SENT,
             status: response.status === "confirmed"
                 ? MessageStatus.CONFIRMED
                 : MessageStatus.PENDING,
-            msgType: encrypted.type, // 使用底层 Signal Protocol 消息类型（1 或 3）
+            msgType: encrypted.type,
             zipMetadata,
             createdAt,
         };
@@ -767,7 +546,6 @@ export class Messenger {
             message.serverSignature = response.merkleData.serverSignature;
             message.serverTimestamp = response.merkleData.serverTimestamp;
             message.serverPublicKey = response.merkleData.serverPublicKey;
-            // 更新会话状态
             this.sessionStateStorage.updateSessionState(this.userAddress, recipientAddress, {
                 currentRoot: response.merkleData.newRoot,
                 prevRoot: response.merkleData.prevRoot,
@@ -776,15 +554,11 @@ export class Messenger {
             });
         }
         this.messageStorage.saveMessage(message);
-        // 方案B：处理服务器返回的其他已验证消息的 Merkle 数据
-        // 这些消息可能之前因为发送方离线而没有收到 Merkle 数据
         if (response.pendingMerkleData) {
             for (const [msgId, merkleData] of Object.entries(response.pendingMerkleData)) {
-                // 检查本地是否已有该消息
                 const existingMsg = this.messageStorage.getMessage(msgId);
                 if (existingMsg &&
                     existingMsg.status === MessageStatus.PENDING) {
-                    // 更新消息的 Merkle 数据
                     this.messageStorage.updateMessageStatus(msgId, MessageStatus.CONFIRMED, {
                         leafIndex: merkleData.leafIndex,
                         newRoot: merkleData.newRoot,
@@ -792,9 +566,6 @@ export class Messenger {
                         serverTimestamp: merkleData.serverTimestamp,
                         serverPublicKey: merkleData.serverPublicKey,
                     });
-                    /*console.log(
-                        `[ForceSend] Updated pending message ${msgId} with merkle data from pendingMerkleData`,
-                    );*/
                 }
             }
         }
@@ -807,13 +578,8 @@ export class Messenger {
             lastReceivedLeafIndex: lastReceivedLeafIndex >= 0 ? lastReceivedLeafIndex : undefined,
         };
     }
-    /**
-     * 加载文件数据（支持本地路径和网络 URL）
-     */
     async loadFileData(source) {
-        // 判断是否为网络 URL
         if (source.startsWith("http://") || source.startsWith("https://")) {
-            // 从网络加载
             const response = await fetch(source);
             if (!response.ok) {
                 throw new MessengerError(MessengerErrorCode.NETWORK_ERROR, `Failed to fetch file from ${source}: ${response.statusText}`);
@@ -821,7 +587,6 @@ export class Messenger {
             const arrayBuffer = await response.arrayBuffer();
             return new Uint8Array(arrayBuffer);
         }
-        // 从本地文件加载
         const resolvedPath = path.resolve(source);
         if (!fs.existsSync(resolvedPath)) {
             throw new MessengerError(MessengerErrorCode.FILE_NOT_FOUND, `File not found: ${resolvedPath}`);
@@ -829,9 +594,6 @@ export class Messenger {
         const buffer = fs.readFileSync(resolvedPath);
         return new Uint8Array(buffer);
     }
-    /**
-     * 检测内容类型
-     */
     detectContentType(fileName) {
         const ext = path.extname(fileName).toLowerCase();
         switch (ext) {
@@ -843,9 +605,6 @@ export class Messenger {
                 return "zip";
         }
     }
-    /**
-     * 生成签名的请求
-     */
     async _createSignedRequest(data) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -857,7 +616,6 @@ export class Messenger {
         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 (await getAccount()).get(this.userAddress, false);
         if (!account || !account.pubkey) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "Account public key not found");
@@ -872,9 +630,6 @@ export class Messenger {
             data,
         };
     }
-    /**
-     * 验证地址列表
-     */
     _validateAddresses(addresses) {
         const valid = [];
         const invalid = [];
@@ -888,9 +643,6 @@ export class Messenger {
         }
         return { valid, invalid };
     }
-    /**
-     * 黑名单 - 添加地址
-     */
     async addToBlacklist(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -911,9 +663,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.addToBlacklist(this.userAddress, signedRequest);
     }
-    /**
-     * 黑名单 - 移除地址
-     */
     async removeFromBlacklist(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -934,9 +683,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.removeFromBlacklist(this.userAddress, signedRequest);
     }
-    /**
-     * 黑名单 - 清空
-     */
     async clearBlacklist() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -945,9 +691,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.clearBlacklist(this.userAddress, signedRequest);
     }
-    /**
-     * 黑名单 - 获取列表
-     */
     async getBlacklist() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -955,9 +698,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest({});
         return this.serverClient.getBlacklist(this.userAddress, signedRequest);
     }
-    /**
-     * 黑名单 - 检查存在
-     */
     async existInBlacklist(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -978,9 +718,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.existInBlacklist(this.userAddress, signedRequest);
     }
-    /**
-     * 好友列表 - 添加地址
-     */
     async addToFriendsList(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1001,9 +738,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.addToFriendsList(this.userAddress, signedRequest);
     }
-    /**
-     * 好友列表 - 移除地址
-     */
     async removeFromFriendsList(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1024,9 +758,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.removeFromFriendsList(this.userAddress, signedRequest);
     }
-    /**
-     * 好友列表 - 清空
-     */
     async clearFriendsList() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1035,9 +766,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.clearFriendsList(this.userAddress, signedRequest);
     }
-    /**
-     * 好友列表 - 获取列表
-     */
     async getFriendsList() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1045,9 +773,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest({});
         return this.serverClient.getFriendsList(this.userAddress, signedRequest);
     }
-    /**
-     * 好友列表 - 检查存在
-     */
     async existInFriendsList(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1068,9 +793,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.existInFriendsList(this.userAddress, signedRequest);
     }
-    /**
-     * Guard 列表 - 添加
-     */
     async addToGuardList(guards) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1079,9 +801,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.addToGuardList(this.userAddress, signedRequest);
     }
-    /**
-     * Guard 列表 - 移除
-     */
     async removeFromGuardList(addresses) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1102,9 +821,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(data);
         return this.serverClient.removeFromGuardList(this.userAddress, signedRequest);
     }
-    /**
-     * Guard 列表 - 获取列表
-     */
     async getGuardList() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1112,9 +828,6 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest({});
         return this.serverClient.getGuardList(this.userAddress, signedRequest);
     }
-    /**
-     * 获取用户设置
-     */
     async getSettings() {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
@@ -1122,14 +835,10 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest({});
         return this.serverClient.getSettings(this.userAddress, signedRequest);
     }
-    /**
-     * 设置用户设置
-     */
     async setSettings(settings) {
         if (!this.userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "User address not set");
         }
-        // 构造完整请求对象
         const fullSettings = {
             allowStrangerMessages: settings.allowStrangerMessages,
             maxInboxSize: settings.maxInboxSize,
@@ -1137,19 +846,11 @@ export class Messenger {
         const signedRequest = await this._createSignedRequest(fullSettings);
         return this.serverClient.updateSettings(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,
@@ -1159,7 +860,6 @@ export class Messenger {
                 };
             }
             const plaintext = decryptResult.plaintext;
-            // 2. 验证消息
             if (!serverMsg.clientTimestamp) {
                 throw new Error(`Missing clientTimestamp for message ${serverMsg.id}`);
             }
@@ -1190,7 +890,6 @@ export class Messenger {
             if (!verificationResult.valid) {
                 throw new Error(verificationResult.error);
             }
-            // 3. 构造消息对象
             const message = {
                 messageId: serverMsg.id,
                 fromAddress: serverMsg.from,
@@ -1213,7 +912,6 @@ export class Messenger {
                 receivedAt: Date.now(),
                 zipMetadata: serverMsg.zipMetadata,
             };
-            // 4. 更新会话状态
             if (serverMsg.merkleMetadata) {
                 this.sessionStateStorage.updateSessionState(this.userAddress, serverMsg.from, {
                     currentRoot: serverMsg.merkleMetadata.newRoot,
@@ -1225,7 +923,6 @@ export class Messenger {
             const timestamp = serverMsg.merkleMetadata?.serverTimestamp ||
                 serverMsg.clientTimestamp ||
                 Date.now();
-            // 【新增】根据收到的 lastReceivedLeafIndex，更新我发送的消息状态
             if (serverMsg.lastReceivedLeafIndex !== undefined &&
                 serverMsg.lastReceivedLeafIndex >= 0) {
                 const mySentMessages = this.messageStorage
@@ -1260,7 +957,6 @@ export class Messenger {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
-            // 判断是否应该重试（Skip Keys 机制）
             const shouldRetry = this.isRetryableError(errorMessage);
             return {
                 success: false,
@@ -1269,37 +965,24 @@ export class Messenger {
             };
         }
     }
-    /**
-     * 判断错误是否可重试（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 的情况
+            /PREKEY 竞争：我的地址较小，保留我的会话/i,
+            /The operation failed for an operation-specific reason/i,
+            /DOMException/i,
+            /收到 WHISPER_MESSAGE 但无现有会话，需要等待 PREKEY_MESSAGE/i,
         ];
         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);
         });
@@ -1309,16 +992,13 @@ export class Messenger {
             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,
@@ -1327,15 +1007,12 @@ export class Messenger {
                 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,
@@ -1347,13 +1024,11 @@ export class Messenger {
                     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);
         }
@@ -1361,11 +1036,6 @@ export class Messenger {
             console.log(`[Messenger] 成功处理 ${processedIds.length} 条等待消息`);
         }
     }
-    /**
-     * 保存解密失败的消息
-     * @param serverMsg 服务器消息
-     * @param error 错误信息
-     */
     async saveFailedMessage(serverMsg, error) {
         const failedMessage = {
             messageId: serverMsg.id,
@@ -1393,9 +1063,6 @@ export class Messenger {
         };
         this.messageStorage.saveMessage(failedMessage);
     }
-    /**
-     * 重新调度轮询（用于切换到快速模式）
-     */
     reschedulePolling() {
         if (!this.isPollingRunning || !this.pollingTimer)
             return;
@@ -1404,10 +1071,6 @@ export class Messenger {
         this.pollingTimer = null;
         this.scheduleNextPoll();
     }
-    /**
-     * 获取解密失败的消息（供用户决策重发）
-     * @returns 失败消息列表
-     */
     getFailedMessages() {
         return Array.from(this.failedMessages.entries()).map(([id, data]) => ({
             messageId: id,
@@ -1416,10 +1079,6 @@ export class Messenger {
             leafIndex: data.message.merkleMetadata?.leafIndex,
         }));
     }
-    /**
-     * 清除解密失败的消息记录
-     * @param messageId 消息ID（可选，不提供则清除所有）
-     */
     clearFailedMessages(messageId) {
         if (messageId) {
             this.failedMessages.delete(messageId);
@@ -1428,12 +1087,7 @@ export class Messenger {
             this.failedMessages.clear();
         }
     }
-    /**
-     * 获取等待解密的消息数量
-     * @returns 等待消息数量
-     */
     getWaitingMessageCount() {
         return this.waitingMessages.size;
     }
 }
-//# sourceMappingURL=messenger.js.map