wowok 2.1.38 → 2.1.40

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

@@ -1,5 +1,3 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
 import { MessengerManager } from "./messenger-manager.js";
 import { Account } from "../local/account.js";
 import { W_ERROR, WErrors } from "../exception.js";
@@ -19,10 +17,6 @@ import { Messenger } from "./messenger.js";
 let managerInstance = null;
 let isInitialized = false;
 let backgroundTimer = null;
-/**
- * 自动检查并注册所有设置了 messenger name 的账号
- * 如果账号已注册（identity 已存在），则跳过
- */
 async function autoRegisterMessengerAccounts() {
     const accounts = await Account.Instance().list_messenger_accounts();
     for (const account of accounts) {
@@ -35,21 +29,15 @@ async function autoRegisterMessengerAccounts() {
         }
         catch (error) {
             console.error(`Failed to initialize account ${account.address}:`, error);
-            // 继续处理下一个账号
         }
     }
 }
-/**
- * 获取 MessengerManager 实例（单例）
- * 首次调用时会自动启动后台服务
- */
 export function getMessengerManager() {
     if (!managerInstance) {
         managerInstance = new MessengerManager();
     }
     if (!isInitialized) {
         isInitialized = true;
-        // 启动时先自动检查并注册账号
         autoRegisterMessengerAccounts().catch((err) => {
             console.error("Failed to auto-register messenger accounts:", err);
         });
@@ -59,9 +47,6 @@ export function getMessengerManager() {
     }
     return managerInstance;
 }
-/**
- * 进程退出时自动清理
- */
 function registerCleanupHandler() {
     const cleanup = () => {
         if (backgroundTimer) {
@@ -83,49 +68,21 @@ function registerCleanupHandler() {
     });
 }
 registerCleanupHandler();
-// startBackgroundTimer(); // 暂时注释掉，避免干扰测试
-/**
- * 获取会话列表
- *
- * 查询当前账号的所有会话，支持多种过滤和排序选项。
- * 返回的 unreadCount 基于 viewedAt 字段计算。
- *
- * @param filter 过滤条件（可选）
- * @returns 会话信息列表，按指定方式排序
- *
- * @example
- * // 获取所有会话（默认按最后消息时间排序，每个会话2条预览，自动标记为已查看）
- * const conversations = await watch_conversations();
- *
- * // 只获取有未读消息的会话
- * const unreadConversations = await watch_conversations({ unreadOnly: true });
- *
- * // 获取最近7天的会话，包含5条预览消息，跳过自动标记
- * const recent = await watch_conversations({
- * 	startTime: Date.now() - 7 * 24 * 60 * 60 * 1000,
- * 	previewMessageCount: 5,
- * 	skipAutoMarkViewed: true
- * });
- */
 export async function watch_conversations(filter) {
     const address = await Account.Instance().get_address(filter?.account);
     if (!address) {
         W_ERROR(WErrors.AccountNotFound, `watch_conversations.account ${filter?.account}`);
     }
     const myAddress = address.toLowerCase();
-    // 【修改】使用 MessengerManager 确保账号已就绪并拉取消息
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
-    // 确保账号已就绪（自动初始化）
     const accountInfo = await manager.ensureAccountReady(address);
-    // 拉取消息
     await accountInfo.messenger.pullMessages();
     const messageStorage = new MessageStorage(myAddress);
     const allMessages = messageStorage.getAllMessages(myAddress);
     const conversations = new Map();
-    // 默认参数
     const previewMessageCount = filter?.previewMessageCount ?? 2;
     const skipAutoMarkViewed = filter?.skipAutoMarkViewed ?? false;
     for (const msg of allMessages) {
@@ -149,16 +106,13 @@ export async function watch_conversations(filter) {
             conv.lastMessageAt = msg.createdAt;
             conv.lastMessagePreview = msg.plaintext;
         }
-        // 未读判断：接收到的消息且没有 viewedAt
         if (msg.direction === MessageDirection.RECEIVED &&
             msg.viewedAt === undefined) {
             conv.unreadCount++;
         }
     }
-    // 构建结果数组
     const result = [];
     for (const [, conv] of conversations) {
-        // 时间段过滤
         if (filter?.startTime !== undefined &&
             conv.lastMessageAt < filter.startTime) {
             continue;
@@ -167,18 +121,14 @@ export async function watch_conversations(filter) {
             conv.lastMessageAt > filter.endTime) {
             continue;
         }
-        // 未读过滤
         if (filter?.unreadOnly && conv.unreadCount === 0) {
             continue;
         }
-        // 准备预览消息
         const previewMessages = [];
         if (previewMessageCount > 0) {
-            // 按时间倒序取最新的消息
             const sortedMessages = conv.messages.sort((a, b) => b.createdAt - a.createdAt);
             const selectedMessages = sortedMessages.slice(0, previewMessageCount);
             previewMessages.push(...selectedMessages.reverse());
-            // 自动标记为已查看（如果不是跳过模式）
             if (!skipAutoMarkViewed) {
                 const unviewedIds = selectedMessages
                     .filter((m) => m.direction === MessageDirection.RECEIVED &&
@@ -198,7 +148,6 @@ export async function watch_conversations(filter) {
             ...(previewMessageCount > 0 && { previewMessages }),
         });
     }
-    // 排序
     const sortBy = filter?.sortBy ?? "lastMessageAt";
     const sortOrder = filter?.sortOrder ?? "desc";
     result.sort((a, b) => {
@@ -218,23 +167,6 @@ export async function watch_conversations(filter) {
     });
     return result;
 }
-/**
- * 标记消息为已查看
- *
- * 将指定消息标记为当前用户已查看，设置 viewedAt 为当前时间戳。
- * 通常用于用户主动查看消息后调用。
- *
- * @param messageIds 消息ID列表（至少1条）
- * @param account 账号地址或名称（可选，默认当前账号）
- * @returns 成功标记的消息数量
- *
- * @example
- * // 标记单条消息
- * await mark_messages_as_viewed(["msg-123"]);
- *
- * // 标记多条消息
- * await mark_messages_as_viewed(["msg-1", "msg-2", "msg-3"]);
- */
 export async function mark_messages_as_viewed(messageIds, account) {
     if (!messageIds || messageIds.length === 0) {
         return 0;
@@ -247,30 +179,12 @@ export async function mark_messages_as_viewed(messageIds, account) {
     const messageStorage = new MessageStorage(myAddress);
     return messageStorage.updateMessagesViewed(messageIds);
 }
-/**
- * 标记整个会话为已查看
- *
- * 将指定会话中的所有未查看消息标记为已查看。
- * 通常用于用户点击进入聊天界面时调用。
- *
- * @param peerAddress 对方地址或名称标记
- * @param account 账号地址或名称（可选，默认当前账号）
- * @returns 成功标记的消息数量
- *
- * @example
- * // 标记与某人的所有消息为已查看
- * await mark_conversation_as_viewed("0x123...");
- *
- * // 使用名称标记
- * await mark_conversation_as_viewed("alice");
- */
 export async function mark_conversation_as_viewed(peerAddress, account) {
     const address = await Account.Instance().get_address(account);
     if (!address) {
         W_ERROR(WErrors.AccountNotFound, `mark_conversation_as_viewed.account ${account}`);
     }
     const myAddress = address.toLowerCase();
-    // 解析对方地址
     const peerAddr = await GetAccountOrMark_Address(peerAddress);
     if (!peerAddr) {
         W_ERROR(WErrors.AccountNotFound, `mark_conversation_as_viewed.peerAddress ${peerAddress} is not a valid account/address`);
@@ -278,7 +192,6 @@ export async function mark_conversation_as_viewed(peerAddress, account) {
     const peerAddrLower = peerAddr.toLowerCase();
     const messageStorage = new MessageStorage(myAddress);
     const sessionMessages = messageStorage.getMessagesBySession(myAddress, peerAddrLower);
-    // 筛选出未查看的接收消息
     const unviewedIds = sessionMessages
         .filter((m) => m.direction === MessageDirection.RECEIVED &&
         m.viewedAt === undefined)
@@ -288,15 +201,6 @@ export async function mark_conversation_as_viewed(peerAddress, account) {
     }
     return messageStorage.updateMessagesViewed(unviewedIds);
 }
-/**
- * 发送消息
- *
- * @param from 发送者地址
- * @param to 接收者地址
- * @param content 消息内容
- * @param options 可选配置
- * @returns SendMessageResult
- */
 export async function send_message(from, to, content, options) {
     const fromAddress = await Account.Instance().get_address(from);
     if (!fromAddress) {
@@ -316,25 +220,12 @@ export async function send_message(from, to, content, options) {
             W_ERROR(WErrors.AccountNotFound, `send_message.guardAddress or passportAddress not found`);
         }
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪并发送消息
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
     return manager.send(fromAddress, t, content, options);
 }
-/**
- * 发送文件（ZIP 格式）
- *
- * 支持发送本地文件，经过 ZIP 压缩后发送给对方
- * 支持 Guard 验证，如果提供 guardAddress 和 passportAddress，消息将进入 Guard 验证流程
- *
- * @param from 发送者账号或地址
- * @param to 接收者地址
- * @param filePath 本地文件路径
- * @param options 可选配置
- * @returns SendMessageResult
- */
 export async function send_file(from, to, filePath, options) {
     const fromAddress = await Account.Instance().get_address(from);
     if (!fromAddress) {
@@ -354,33 +245,12 @@ export async function send_file(from, to, filePath, options) {
             W_ERROR(WErrors.AccountNotFound, `send_file.guardAddress or passportAddress not found`);
         }
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪并发送文件
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
     return manager.send_file(fromAddress, t, filePath, options);
 }
-/**
- * 查询消息
- *
- * 支持按已读状态过滤，可自动标记为已查看。
- *
- * @param filter 过滤条件（可选）
- * @returns Message 数组
- *
- * @example
- * // 获取所有未读消息（不自动标记）
- * const unread = await watch_messages({ viewed: false, skipAutoMarkViewed: true });
- *
- * // 获取并自动标记为已查看（用户进入聊天界面）
- * const messages = await watch_messages({
- * 	peerAddress: "0x123...",
- * });
- *
- * // 获取已查看的消息
- * const viewed = await watch_messages({ viewed: true });
- */
 export async function watch_messages(filter) {
     if (filter?.account !== undefined) {
         filter.account = await Account.Instance().get_address(filter.account);
@@ -394,18 +264,15 @@ export async function watch_messages(filter) {
     if (filter?.customListFilter?.excludeAddresses != null) {
         filter.customListFilter.excludeAddresses = (await Account.Instance().get_many_address(filter.customListFilter.excludeAddresses)).filter((v) => v != null);
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪并查询消息
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
     const messages = await manager.watch(filter);
-    // 自动标记为已查看（如果不是跳过模式）
     const skipAutoMarkViewed = filter?.skipAutoMarkViewed ?? false;
     if (!skipAutoMarkViewed && messages.length > 0 && filter?.account) {
         const myAddress = filter.account.toLowerCase();
         const messageStorage = new MessageStorage(myAddress);
-        // 筛选出未查看的接收消息
         const unviewedIds = messages
             .filter((m) => m.direction === MessageDirection.RECEIVED &&
             m.viewedAt === undefined)
@@ -421,7 +288,6 @@ export async function pull_messages(account, limit) {
     if (!address) {
         W_ERROR(WErrors.AccountNotFound, `pull_messages.account ${account}`);
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪并拉取消息
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
@@ -430,13 +296,6 @@ export async function pull_messages(account, limit) {
     const result = await accountInfo.messenger.pullMessages(limit);
     return result.messages.map((dm) => dm);
 }
-/**
- * 解压 ZIP 消息到指定目录
- *
- * @param message 包含 ZIP 数据的消息对象
- * @param outputDir 输出目录路径
- * @returns 解压后的文件路径
- */
 async function extract_zip_message(message, outputDir) {
     if (!message.zipMetadata) {
         throw new MessengerError(MessengerErrorCode.INVALID_MESSAGE_TYPE, "Message is not a ZIP archive");
@@ -444,10 +303,8 @@ async function extract_zip_message(message, outputDir) {
     if (!message.plaintext) {
         throw new MessengerError(MessengerErrorCode.MESSAGE_NOT_DECRYPTED, "Message plaintext not available");
     }
-    // 1. 解码 base64 ZIP 数据
     const zipBase64 = message.plaintext;
     const zipData = Buffer.from(zipBase64, "base64");
-    // 2. 验证文件哈希
     if (message.zipMetadata?.fileHash) {
         const actualHash = createHash("sha256").update(zipData).digest("hex");
         const expectedHash = message.zipMetadata.fileHash.replace("0x", "");
@@ -455,15 +312,12 @@ async function extract_zip_message(message, outputDir) {
             throw new MessengerError(MessengerErrorCode.HASH_MISMATCH, `ZIP file hash mismatch: expected ${expectedHash}, got ${actualHash}`);
         }
     }
-    // 3. 解压 ZIP 文件
     const { ZipReader, BlobReader, BlobWriter } = await import("@zip.js/zip.js");
     const zipReader = new ZipReader(new BlobReader(new Blob([zipData])));
     const entries = await zipReader.getEntries();
-    // 4. 确保输出目录存在
     if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
-    // 5. 保存文件
     const savedPaths = [];
     for (const entry of entries) {
         if (!entry.directory) {
@@ -477,7 +331,6 @@ async function extract_zip_message(message, outputDir) {
         }
     }
     await zipReader.close();
-    // 6. 更新消息元数据
     if (savedPaths.length > 0 && message.zipMetadata) {
         const updatedMetadata = {
             fileName: message.zipMetadata.fileName,
@@ -488,7 +341,6 @@ async function extract_zip_message(message, outputDir) {
             downloadedAt: Date.now(),
         };
         message.zipMetadata = updatedMetadata;
-        // 根据消息方向确定用户地址
         const userAddress = message.direction === "sent"
             ? message.fromAddress
             : message.toAddress;
@@ -497,14 +349,6 @@ async function extract_zip_message(message, outputDir) {
     }
     return savedPaths[0] || "";
 }
-/**
- * 批量解压多个 ZIP 消息到指定目录
- *
- * @param messages 包含 ZIP 数据的消息数组，或消息 ID 数组
- * @param outputDir 输出目录路径
- * @param userAddress 用户地址（当传入消息ID数组时需要）
- * @returns 解压后的文件路径数组
- */
 export async function extract_zip_messages(account, messages, outputDir) {
     const results = [];
     const userAddress = await Account.Instance().get_address(account);
@@ -514,7 +358,6 @@ export async function extract_zip_messages(account, messages, outputDir) {
     for (const item of messages) {
         try {
             let message;
-            // 逐个判断是 Message 对象还是 messageId 字符串
             if (typeof item === "string") {
                 const messageId = item;
                 const messageStorage = new MessageStorage(userAddress);
@@ -528,7 +371,6 @@ export async function extract_zip_messages(account, messages, outputDir) {
             else {
                 message = item;
             }
-            // 检查是否为 ZIP 消息
             if (!message.zipMetadata) {
                 console.error(`Message ${message.messageId} is not a ZIP archive`);
                 continue;
@@ -554,22 +396,10 @@ export async function generate_wts(params) {
     }
     return getMessengerManager().generate_wts(params.outputDir, myAddress, peerAddress, params.range, params.excludePlaintext);
 }
-/**
- * 加载 WTS 文件
- *
- * @param filePath WTS 文件路径
- * @returns WtsFile 对象
- */
 function load_wts(filePath) {
     const content = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
 }
-/**
- * 保存 WTS 文件
- *
- * @param wtsFile WTS 文件对象
- * @param filePath 保存路径
- */
 function save_wts(wtsFile, filePath) {
     const dir = path.dirname(filePath);
     if (!fs.existsSync(dir)) {
@@ -577,24 +407,9 @@ function save_wts(wtsFile, filePath) {
     }
     fs.writeFileSync(filePath, JSON.stringify(wtsFile, null, 2), "utf-8");
 }
-/**
- * 验证 WTS 文件
- *
- * 验证内容包括：
- * 1. 文件结构完整性
- * 2. Merkle 链连续性
- * 3. 消息哈希格式
- * 4. Payload 哈希匹配
- * 5. 数字签名（如果存在）
- *
- * @param wtsFilePath WTS 文件路径（本地或网络文件）
- * @returns 验证结果
- */
 export async function verify_wts(wtsFilePath) {
     try {
-        // 1. 加载 WTS 文件
         const wtsFile = load_wts(wtsFilePath);
-        // 2. 验证基本结构
         if (!wtsFile.payload || !wtsFile.meta) {
             return { valid: false, error: "Invalid WTS file structure" };
         }
@@ -605,8 +420,6 @@ export async function verify_wts(wtsFilePath) {
             };
         }
         const { payload, meta } = wtsFile;
-        // 2. 验证每个消息的 Merkle Root 计算和链连续性
-        // 首先按leafIndex排序消息
         const sortedMessages = [...payload.messages].sort((a, b) => {
             if (a.leafIndex === undefined || b.leafIndex === undefined)
                 return 0;
@@ -614,14 +427,12 @@ export async function verify_wts(wtsFilePath) {
         });
         for (let i = 0; i < sortedMessages.length; i++) {
             const msg = sortedMessages[i];
-            // 检查消息对象是否为空
             if (!msg) {
                 return {
                     valid: false,
                     error: `Message ${i}: Message is null or undefined`,
                 };
             }
-            // 检查关键字段是否为空
             if (!msg.prevRoot) {
                 return {
                     valid: false,
@@ -652,7 +463,6 @@ export async function verify_wts(wtsFilePath) {
                     error: `Message ${i}: Missing leafIndex`,
                 };
             }
-            // 验证单个消息的Merkle Root计算
             const result = verifySingleMerkleRoot(msg.prevRoot, msg.merkleRoot, msg.plaintextHash, msg.timestamp, msg.leafIndex);
             if (!result.valid) {
                 return {
@@ -660,17 +470,14 @@ export async function verify_wts(wtsFilePath) {
                     error: `${result.error} at message ${i}, leafIndex ${msg.leafIndex}`,
                 };
             }
-            // 【新增】验证Merkle链连续性（除了第一条消息）
             if (i > 0) {
                 const prevMsg = sortedMessages[i - 1];
-                // 检查leafIndex是否连续
                 if (msg.leafIndex !== prevMsg.leafIndex + 1) {
                     return {
                         valid: false,
                         error: `Merkle chain discontinuity: leafIndex ${prevMsg.leafIndex} -> ${msg.leafIndex} (expected ${prevMsg.leafIndex + 1})`,
                     };
                 }
-                // 检查merkleRoot是否匹配
                 if (msg.prevRoot.toLowerCase() !==
                     prevMsg.merkleRoot.toLowerCase()) {
                     return {
@@ -680,21 +487,16 @@ export async function verify_wts(wtsFilePath) {
                 }
             }
         }
-        // 3. 验证每个消息的 plaintextHash 和服务器签名（如果提供了明文）
         for (let i = 0; i < payload.messages.length; i++) {
             const msg = payload.messages[i];
-            // 检查消息对象是否为空
             if (!msg) {
                 return {
                     valid: false,
                     error: `Message ${i}: Message is null or undefined`,
                 };
             }
-            // 判断是否为非文本消息（ZIP/WTS/WIP）
             const isNonTextMsg = !!msg.zipMetadata;
-            // 对于非文本消息，跳过 plaintextHash 格式验证（它们使用不同的哈希格式）
             if (!isNonTextMsg) {
-                // 验证普通消息的 plaintextHash 格式
                 if (!msg.plaintextHash.startsWith("0x") ||
                     msg.plaintextHash.length !== 66) {
                     return {
@@ -702,7 +504,6 @@ export async function verify_wts(wtsFilePath) {
                         error: `Message ${i}: Invalid plaintextHash format`,
                     };
                 }
-                // 如果提供了明文，验证 plaintextHash
                 if (msg.plaintext) {
                     const computedHash = hashPlaintext(msg.plaintext, msg.clientTimestamp, msg.guardAddress, msg.passportAddress, msg.lastReceivedLeafIndex);
                     if (computedHash.toLowerCase() !==
@@ -714,9 +515,7 @@ export async function verify_wts(wtsFilePath) {
                     }
                 }
             }
-            // 验证服务器签名（如果提供了签名和公钥）
             if (msg.serverSignature && msg.serverPublicKey) {
-                // 检查必需的字段
                 if (!msg.timestamp) {
                     return {
                         valid: false,
@@ -745,32 +544,11 @@ export async function verify_wts(wtsFilePath) {
                 }
             }
         }
-        // 4. 验证 payload 哈希
         const { sha256 } = await import("@noble/hashes/sha256");
         const { bytesToHex } = await import("@noble/hashes/utils");
         const canonicalPayload = canonicalizeJson(payload);
         const computedHash = "sha256:" +
             bytesToHex(sha256(new TextEncoder().encode(canonicalPayload)));
-        // DEBUG: 打印调试信息
-        /*console.log("=== WTS Hash Verification Debug ===");
-        console.log("Stored hash:", meta.hash);
-        console.log("Computed hash:", computedHash);
-        console.log(
-            "Canonical payload:",
-            canonicalPayload.substring(0, 500) + "...",
-        );
-        console.log("Payload keys:", Object.keys(payload));
-        console.log("Messages count:", payload.messages.length);
-        if (payload.messages.length > 0) {
-            console.log(
-                "First message keys:",
-                Object.keys(payload.messages[0]),
-            );
-            console.log(
-                "First message:",
-                JSON.stringify(payload.messages[0], null, 2).substring(0, 500),
-            );
-        }*/
         if (computedHash !== meta.hash) {
             return {
                 valid: false,
@@ -779,12 +557,10 @@ export async function verify_wts(wtsFilePath) {
                 hasSignature: !!meta.signature,
             };
         }
-        // 5. 验证数字签名（如果存在）
         const signatures = [];
         let signatureValid;
         if (meta.signature) {
             const { Ed25519PublicKey } = await import("../../keypairs/ed25519/publickey.js");
-            // 支持多签名验证
             const sigArray = Array.isArray(meta.signature)
                 ? meta.signature
                 : [meta.signature];
@@ -793,7 +569,6 @@ export async function verify_wts(wtsFilePath) {
                 let pkToUse;
                 const pk = sig.publicKey;
                 if (pk.startsWith("0x")) {
-                    // 16进制格式，转换为base64
                     const buffer = Buffer.from(pk.slice(2), "hex");
                     if (buffer.length === 33) {
                         pkToUse = buffer.slice(1).toString("base64");
@@ -802,14 +577,12 @@ export async function verify_wts(wtsFilePath) {
                         pkToUse = buffer.toString("base64");
                     }
                     else {
-                        // 尝试推导地址
                         let address;
                         try {
                             const pubKey = new Ed25519PublicKey(pk.slice(2));
                             address = pubKey.toWAddress();
                         }
                         catch {
-                            // 推导失败不影响
                         }
                         signatures.push({
                             publicKey: pk,
@@ -821,7 +594,6 @@ export async function verify_wts(wtsFilePath) {
                     }
                 }
                 else {
-                    // 假设是base64格式，但需要确保是32字节
                     try {
                         const buffer = Buffer.from(pk, "base64");
                         if (buffer.length === 33) {
@@ -831,14 +603,12 @@ export async function verify_wts(wtsFilePath) {
                             pkToUse = buffer.toString("base64");
                         }
                         else {
-                            // 尝试推导地址
                             let address;
                             try {
                                 const pubKey = new Ed25519PublicKey(pk);
                                 address = pubKey.toWAddress();
                             }
                             catch {
-                                // 推导失败不影响
                             }
                             signatures.push({
                                 publicKey: pk,
@@ -850,7 +620,6 @@ export async function verify_wts(wtsFilePath) {
                         }
                     }
                     catch {
-                        // 如果解码失败，直接使用原始值
                         pkToUse = pk;
                     }
                 }
@@ -858,13 +627,11 @@ export async function verify_wts(wtsFilePath) {
                     const pubKey = new Ed25519PublicKey(pkToUse);
                     const signatureBytes = Uint8Array.from(Buffer.from(sig.value, "base64"));
                     const signValid = await pubKey.verify(new TextEncoder().encode(meta.hash), signatureBytes);
-                    // 通过公钥推导地址
                     let address;
                     try {
                         address = pubKey.toWAddress();
                     }
                     catch {
-                        // 推导失败不影响验证
                     }
                     signatures.push({
                         publicKey: pk,
@@ -876,14 +643,12 @@ export async function verify_wts(wtsFilePath) {
                     }
                 }
                 catch {
-                    // 尝试推导地址
                     let address;
                     try {
                         const pubKey = new Ed25519PublicKey(pkToUse);
                         address = pubKey.toWAddress();
                     }
                     catch {
-                        // 推导失败不影响
                     }
                     signatures.push({ publicKey: pk, address, valid: false });
                     allValid = false;
@@ -891,7 +656,6 @@ export async function verify_wts(wtsFilePath) {
             }
             signatureValid = allValid;
             if (!signatureValid) {
-                // 收集失败的地址
                 const failedAddresses = signatures
                     .filter((s) => !s.valid && s.address)
                     .map((s) => s.address);
@@ -922,38 +686,22 @@ export async function verify_wts(wtsFilePath) {
         };
     }
 }
-/**
- * 使用账号签名 WTS 文件
- *
- * 此函数会自动加载 WTS 文件、验证格式、签名并保存。
- *
- * @param wtsFilePath WTS 文件路径（本地或网络文件）
- * @param account 签名账号
- * @param outputPath 输出文件路径（可选，默认覆盖原文件）
- * @returns 签名后的 WTS 文件路径
- */
 export async function sign_wts(wtsFilePath, account, outputPath) {
-    // 1. 验证 WTS 文件格式（内部会加载文件）
     const verifyResult = await verify_wts(wtsFilePath);
     if (!verifyResult.valid) {
         throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `WTS file verification failed: ${verifyResult.error}`);
     }
-    // 2. 加载 WTS 文件
     const wtsFile = load_wts(wtsFilePath);
-    // 3. 获取签名者地址
     const address = await Account.Instance().get_address(account);
     if (!address) {
         W_ERROR(WErrors.AccountNotFound, `sign_wts.account ${account}`);
     }
-    // 4. 使用 Account 签名（同时获取公钥）
     const signResult = await Account.Instance().signData(address, wtsFile.meta.hash);
-    // 6. 转换公钥格式为 base64 (32字节)
     let publicKeyBase64;
     const pk = signResult.publicKey;
     if (pk.startsWith("0x")) {
         const buffer = Buffer.from(pk.slice(2), "hex");
         if (buffer.length === 33) {
-            // 去掉第一个字节（通常是压缩标志）
             publicKeyBase64 = buffer.slice(1).toString("base64");
         }
         else if (buffer.length === 32) {
@@ -964,39 +712,31 @@ export async function sign_wts(wtsFilePath, account, outputPath) {
         }
     }
     else {
-        // 假设已经是 base64 格式
         publicKeyBase64 = pk;
     }
-    // 7. 构建新签名
     const newSignature = {
         value: Buffer.from(signResult.signature.slice(2), "hex").toString("base64"),
         publicKey: publicKeyBase64,
         algorithm: "Ed25519",
         address: signResult.address,
     };
-    // 8. 处理多签名：相同公钥只能有一个签名（替换已有签名）
     let signatures;
     if (wtsFile.meta.signature) {
-        // 将已有签名转换为数组
         const existingSigs = Array.isArray(wtsFile.meta.signature)
             ? [...wtsFile.meta.signature]
             : [wtsFile.meta.signature];
-        // 检查是否已存在相同公钥的签名
         const existingIndex = existingSigs.findIndex((sig) => sig.publicKey === publicKeyBase64);
         if (existingIndex >= 0) {
-            // 替换已有签名
             existingSigs[existingIndex] = newSignature;
             signatures = existingSigs;
         }
         else {
-            // 追加新签名
             signatures = [...existingSigs, newSignature];
         }
     }
     else {
         signatures = [newSignature];
     }
-    // 9. 添加签名到 meta
     const signedWtsFile = {
         ...wtsFile,
         meta: {
@@ -1004,13 +744,11 @@ export async function sign_wts(wtsFilePath, account, outputPath) {
             signature: signatures,
         },
     };
-    // 8. 确定保存路径
     let savePath;
     if (outputPath) {
         savePath = outputPath;
     }
     else {
-        // 在原文件名前添加 signed_ 前缀
         const dir = path.dirname(wtsFilePath);
         const ext = path.extname(wtsFilePath);
         const baseName = path.basename(wtsFilePath, ext);
@@ -1022,10 +760,8 @@ export async function sign_wts(wtsFilePath, account, outputPath) {
 export async function wts2html(wtsPath, options = {}) {
     const fs = await import("fs");
     const path = await import("path");
-    // 检查是文件还是文件夹
     const stats = fs.statSync(wtsPath);
     if (stats.isDirectory()) {
-        // 处理文件夹中的所有 .wts 文件
         const files = fs.readdirSync(wtsPath);
         const wtsFiles = files.filter((f) => f.endsWith(".wts"));
         if (wtsFiles.length === 0) {
@@ -1035,12 +771,10 @@ export async function wts2html(wtsPath, options = {}) {
         for (const file of wtsFiles) {
             const filePath = path.join(wtsPath, file);
             const html = await convertWtsToHtml(filePath, options);
-            // 生成输出文件名
             const outputFileName = file.replace(".wts", ".html");
             const outputFilePath = options.outputPath
                 ? path.join(options.outputPath, outputFileName)
                 : path.join(wtsPath, outputFileName);
-            // 确保输出目录存在
             const outputDir = path.dirname(outputFilePath);
             if (!fs.existsSync(outputDir)) {
                 fs.mkdirSync(outputDir, { recursive: true });
@@ -1050,14 +784,10 @@ export async function wts2html(wtsPath, options = {}) {
         }
         return results;
     }
-    // 处理单个文件
     const html = await convertWtsToHtml(wtsPath, options);
-    // 如果指定了输出路径，保存到文件
     if (options.outputPath) {
-        // 生成输出文件名
         const outputFileName = path.basename(wtsPath).replace(".wts", ".html");
         const outputFilePath = path.join(options.outputPath, outputFileName);
-        // 确保输出目录存在
         const outputDir = path.dirname(outputFilePath);
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
@@ -1067,36 +797,24 @@ export async function wts2html(wtsPath, options = {}) {
     }
     return html;
 }
-/**
- * 将单个 WTS 文件转换为 HTML
- */
 async function convertWtsToHtml(wtsFilePath, options = {}) {
     const { title = "WTS Document", theme = "light" } = options;
-    // 1. 验证文件
     const verifyResult = await verify_wts(wtsFilePath);
-    // 2. 加载 WTS 文件
     const wtsFile = load_wts(wtsFilePath);
     const { payload, meta } = wtsFile;
-    // 获取主题颜色
     const { bgColor, textColor, borderColor } = getThemeColors(theme);
-    // 【修正】分析消息确定"我"是谁，并收集最大 lastReceivedLeafIndex
-    // 算法：找出生成WTS的账户（myAccount）收到的消息中，lastReceivedLeafIndex的最大值
-    // 生成WTS的账户 = meta.creator
     const myAddress = meta.creator;
     let maxLastReceivedLeafIndex = -1;
     for (const msg of payload.messages) {
-        // 只考虑"我"收到的消息（to === myAddress）
         if (msg.to.toLowerCase() === myAddress.toLowerCase()) {
             if (msg.lastReceivedLeafIndex !== undefined &&
                 msg.lastReceivedLeafIndex >= 0) {
-                // 收集最大 lastReceivedLeafIndex
                 if (msg.lastReceivedLeafIndex > maxLastReceivedLeafIndex) {
                     maxLastReceivedLeafIndex = msg.lastReceivedLeafIndex;
                 }
             }
         }
     }
-    // 使用模板生成 HTML
     return generateHtmlPage({
         title,
         theme,
@@ -1110,47 +828,30 @@ async function convertWtsToHtml(wtsFilePath, options = {}) {
         myAddress,
     });
 }
-/**
- * 提交消息链上证明
- *
- * 将消息的 Merkle 证明提交到链上，创建不可篡改的证明记录。
- * 此函数会先验证消息的完整性和合法性。
- *
- * @param account 账号名称或地址
- * @param messageId 消息ID
- * @param env 调用环境（包含网络、签名账号等）
- * @returns 证明对象地址
- */
 export async function proof_message(account, messageId, network) {
-    // 1. 解析账号地址
     const address = await Account.Instance().get_address(account);
     if (!address) {
         W_ERROR(WErrors.AccountNotFound, `proof_message.account ${account}`);
     }
-    // 2. 获取消息
     const messageStorage = new MessageStorage(address);
     const message = messageStorage.getMessageById(messageId);
     if (!message) {
         throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message not found: ${messageId}`);
     }
-    // 3. 验证消息属于该账号
     if (message.fromAddress.toLowerCase() !== address.toLowerCase() &&
         message.toAddress.toLowerCase() !== address.toLowerCase()) {
         throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message does not belong to account ${address}`);
     }
-    // 4. 验证服务器签名存在
     if (!message.serverSignature) {
         throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Message does not have server signature`);
     }
     if (!message.serverPublicKey) {
         throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Message does not have server public key`);
     }
-    // 5. 使用 verifyMessage 验证消息完整性（包含服务器签名验证）
     if (!message.plaintext) {
         throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Message does not have plaintext`);
     }
     const { verifyMessage } = await import("./crypto.js");
-    // 构造验证参数
     const verifyParams = {
         messageId: message.messageId,
         plaintext: message.plaintext,
@@ -1162,9 +863,7 @@ export async function proof_message(account, messageId, network) {
         serverSignature: message.serverSignature,
         serverPublicKey: message.serverPublicKey,
     };
-    // 如果消息有完整的 Merkle 证明数据，则添加 merkleMetadata
     if (message.newRoot && message.leafIndex !== undefined) {
-        // 检查服务器时间戳是否存在
         if (!message.serverTimestamp) {
             throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Message ${message.messageId} missing server timestamp for verification`);
         }
@@ -1172,42 +871,35 @@ export async function proof_message(account, messageId, network) {
             newRoot: message.newRoot,
             prevRoot: message.prevRoot,
             leafIndex: message.leafIndex,
-            serverTimestamp: message.serverTimestamp, // 必须使用服务器时间戳
-            // 注意：proofSiblings 和 proofIndices 从服务器拉取时不提供
-            // verifyMessage 会跳过 Merkle Proof 验证，只验证 Root 计算
+            serverTimestamp: message.serverTimestamp,
         };
     }
     const verifyResult = verifyMessage(verifyParams);
     if (!verifyResult.valid) {
         throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Message verification failed: ${verifyResult.error}`);
     }
-    // 6. 从消息中获取服务器公钥
     if (!message.serverPublicKey) {
         throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Message does not have server public key`);
     }
-    // 7. 创建链上证明
     const { CallProof } = await import("../call/proof.js");
     const callProof = new CallProof({
-        proof: message.newRoot, // 证明root存在
+        proof: message.newRoot,
         server_pubkey: message.serverPublicKey,
         server_signature: message.serverSignature,
-        proof_type: CHAIN_PROOF_TYPE, // 消息证明类型
+        proof_type: CHAIN_PROOF_TYPE,
         description: `Message proof for ${messageId}`,
         item_count: message.leafIndex ?? 1,
         about_address: message.fromAddress.toLowerCase() === address.toLowerCase()
             ? message.toAddress
             : message.fromAddress,
     });
-    // 8. 构造调用环境并执行
     const env = {
         network,
         account: address,
     };
     const result = await callProof.call(env);
-    // 9. 使用 ResponseData 提取 Proof 对象地址
     const { ResponseData: extractResponseData } = await import("../call/base.js");
     const responseData = extractResponseData(result);
-    // 查找 Proof 类型的对象
     const proofResult = responseData.find((item) => item.type === "Proof");
     if (!proofResult || !proofResult.object) {
         throw new MessengerError(MessengerErrorCode.INVALID_PROOF, `Failed to get proof address from transaction result`);
@@ -1216,27 +908,20 @@ export async function proof_message(account, messageId, network) {
     messageStorage.saveMessage(message);
     return { proofAddress: proofResult.object };
 }
-const MIN_PASSPORT_VALIDITY = 10; // 10 seconds
-const MAX_PASSPORT_VALIDITY = 10 * 365 * 24 * 60 * 60; // 10 years in seconds
+const MIN_PASSPORT_VALIDITY = 10;
+const MAX_PASSPORT_VALIDITY = 10 * 365 * 24 * 60 * 60;
 const MAX_BLACKLIST_SIZE_ONCE = 100;
 const MAX_FRIENDS_SIZE_ONCE = 100;
 const MAX_GUARDS_SIZE_ONCE = 10;
-/**
- * 黑名单管理 - 统一入口
- * @param request 操作请求
- * @returns 操作结果
- */
 export async function blacklist(request) {
     const acc = await Account.Instance().get_address(request.account);
     if (!acc) {
         W_ERROR(WErrors.AccountNotFound, `blacklist.account ${request.account}`);
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
-    // 确保账号已就绪（自动初始化）
     await manager.ensureAccountReady(acc);
     switch (request.op) {
         case "add": {
@@ -1244,7 +929,6 @@ export async function blacklist(request) {
             if (addresses.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `blacklist.add.users ${request.users} have not valid addresses`);
             }
-            // 去重
             addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
             if (addresses.length > MAX_BLACKLIST_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `blacklist.add.users ${request.users} have too many addresses, max ${MAX_BLACKLIST_SIZE_ONCE}`);
@@ -1257,7 +941,6 @@ export async function blacklist(request) {
             if (addresses.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `blacklist.remove.users ${request.users} have not valid addresses`);
             }
-            // 去重
             addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
             if (addresses.length > MAX_BLACKLIST_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `blacklist.remove.users ${request.users} have too many addresses, max ${MAX_BLACKLIST_SIZE_ONCE}`);
@@ -1278,7 +961,6 @@ export async function blacklist(request) {
             if (addresses.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `blacklist.exist.users ${request.users} have not valid addresses`);
             }
-            // 去重
             addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
             if (addresses.length > MAX_BLACKLIST_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `blacklist.exist.users ${request.users} have too many addresses, max ${MAX_BLACKLIST_SIZE_ONCE}`);
@@ -1290,22 +972,15 @@ export async function blacklist(request) {
             throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `blacklist.unknown op: ${request}`);
     }
 }
-/**
- * 好友列表管理 - 统一入口
- * @param request 操作请求
- * @returns 操作结果
- */
 export async function friendslist(request) {
     const acc = await Account.Instance().get_address(request.account);
     if (!acc) {
         W_ERROR(WErrors.AccountNotFound, `friendslist.account ${request.account}`);
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
-    // 确保账号已就绪（自动初始化）
     await manager.ensureAccountReady(acc);
     switch (request.op) {
         case "add": {
@@ -1313,7 +988,6 @@ export async function friendslist(request) {
             if (addresses.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `friendslist.add.users ${request.users} have not valid addresses`);
             }
-            // 去重
             addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
             const result = await manager.addToFriendsList(acc, addresses);
             return { op: "add", result };
@@ -1323,7 +997,6 @@ export async function friendslist(request) {
             if (addresses.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `friendslist.remove.users ${request.users} have not valid addresses`);
             }
-            // 去重
             addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
             if (addresses.length > MAX_FRIENDS_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `friendslist.remove.users ${request.users} have too many addresses, max ${MAX_FRIENDS_SIZE_ONCE}`);
@@ -1344,7 +1017,6 @@ export async function friendslist(request) {
             if (addresses.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `friendslist.exist.users ${request.users} have not valid addresses`);
             }
-            // 去重
             addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
             if (addresses.length > MAX_FRIENDS_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `friendslist.exist.users ${request.users} have too many addresses, max ${MAX_FRIENDS_SIZE_ONCE}`);
@@ -1356,26 +1028,18 @@ export async function friendslist(request) {
             throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `friendslist.unknown op: ${request}`);
     }
 }
-/**
- * Guard 列表管理 - 统一入口
- * @param request 操作请求
- * @returns 操作结果
- */
 export async function guardlist(request) {
     const acc = await Account.Instance().get_address(request.account);
     if (!acc) {
         W_ERROR(WErrors.AccountNotFound, `guardlist.account ${request.account}`);
     }
-    // 【修改】使用 MessengerManager 确保账号已就绪
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
-    // 确保账号已就绪（自动初始化）
     await manager.ensureAccountReady(acc);
     switch (request.op) {
         case "add": {
-            // 按 guard 字段去重，保留最后一个
             const uniqueGuardsMap = new Map();
             for (const g of request.guards) {
                 uniqueGuardsMap.set(g.guard.toLowerCase(), g);
@@ -1384,11 +1048,9 @@ export async function guardlist(request) {
             if (guards.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `guardlist.add.guards ${request.guards} have not valid guards`);
             }
-            // 去重
             if (guards.length > MAX_GUARDS_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `guardlist.add.guards ${request.guards} have too many guards, max ${MAX_GUARDS_SIZE_ONCE}`);
             }
-            // Validate TTL range
             for (const g of guards) {
                 if (!isValidU64(g.passportValiditySeconds) ||
                     g.passportValiditySeconds < MIN_PASSPORT_VALIDITY ||
@@ -1397,7 +1059,6 @@ export async function guardlist(request) {
                 }
             }
             const addresses = await LocalMark.Instance().get_many_address(guards.map((g) => g.guard));
-            // Validate all addresses were found
             if (addresses.length !== guards.length) {
                 const foundAddresses = new Set(addresses);
                 const missingGuards = [];
@@ -1409,7 +1070,6 @@ export async function guardlist(request) {
                 }
                 W_ERROR(WErrors.InvalidParam, `Guard not found: ${missingGuards.join(", ")}`);
             }
-            // 通过查询检查是不是guard地址
             const objs = await query_objects({
                 objects: addresses,
                 no_cache: false,
@@ -1437,7 +1097,6 @@ export async function guardlist(request) {
             if (guards.length === 0) {
                 W_ERROR(WErrors.InvalidParam, `guardlist.remove.guards ${request.guards} have not valid guards`);
             }
-            // 去重
             if (guards.length > MAX_GUARDS_SIZE_ONCE) {
                 W_ERROR(WErrors.InvalidParam, `guardlist.remove.guards ${request.guards} have too many guards, max ${MAX_GUARDS_SIZE_ONCE}`);
             }
@@ -1463,22 +1122,15 @@ export async function guardlist(request) {
             throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `guardlist.unknown op: ${request}`);
     }
 }
-/**
- * 用户设置管理 - 统一入口
- * @param request 操作请求
- * @returns 操作结果
- */
 export async function settings(request) {
     const acc = await Account.Instance().get_address(request.account);
     if (!acc) {
         W_ERROR(WErrors.AccountNotFound, `settings.account ${request.account}`);
     }
-    // 使用 MessengerManager 确保账号已就绪
     const manager = getMessengerManager();
     if (!isInitialized) {
         await manager.start();
     }
-    // 确保账号已就绪（自动初始化）
     await manager.ensureAccountReady(acc);
     switch (request.op) {
         case "get": {
@@ -1500,4 +1152,3 @@ export async function settings(request) {
             throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `settings.unknown op: ${request}`);
     }
 }
-//# sourceMappingURL=messenger-api.js.map