wowok 2.1.39 → 2.1.40

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

@@ -1,23 +1,9 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Messenger 会话管理模块
- *
- * 基于 Signal Protocol 的双棘轮算法实现端到端加密
- * 负责：
- * 1. 身份密钥管理（与 wowok 账户体系集成）
- * 2. 会话建立和维护
- * 3. 消息加密和解密
- */
 import { KeyHelper, SessionBuilder, SessionCipher, SignalProtocolAddress, } from "libsignal-protocol-typescript";
 import { SignalProtocolStorage } from "./storage.js";
 import { MessengerServerClient } from "./server.js";
 import { recoverXed25519FromX25519PrivateKey, arrayBufferToUint8Array, bytesToBase64, base64ToBytes, } from "./crypto.js";
 import { MessageType, DEFAULT_MESSENGER_CONFIG, MessengerError, MessengerErrorCode, DEFAULT_DEVICE_ID, } from "./types.js";
-// 动态导入 Account 以避免循环依赖
-// eslint-disable-next-line import/no-cycle
 async function getAccount() {
-    // eslint-disable-next-line import/no-cycle
     const { Account } = await import("../local/account.js");
     return Account.Instance();
 }
@@ -31,17 +17,10 @@ export class MessengerSession {
         this.config = { ...DEFAULT_MESSENGER_CONFIG, ...config };
         this.serverClient = new MessengerServerClient(this.config);
     }
-    /**
-     * 获取或创建本地身份
-     *
-     * 从 wowok 账户的 ED25519 私钥确定性派生 X25519 密钥对，
-     * 确保恢复钱包后加密身份不变。
-     */
     async ensureIdentity(userAddress) {
         if (this.identity) {
             return this.identity;
         }
-        // 尝试从存储加载
         const existingSignalIdentity = await this.store.getIdentityKeyPair();
         const existingRegId = await this.store.getLocalRegistrationId();
         if (existingSignalIdentity && existingRegId) {
@@ -54,18 +33,13 @@ export class MessengerSession {
             };
             return this.identity;
         }
-        // 从 ED25519 私钥确定性派生 X25519 密钥对
         if (!userAddress) {
             throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, "userAddress is required to derive identity");
         }
-        // 从 Account 派生 X25519 密钥对
         const { privateKey, publicKey } = await (await getAccount()).deriveX25519KeyPair(userAddress);
-        // 生成注册 ID（可以从公钥派生，确保确定性）
         const registrationId = this.deriveRegistrationId(publicKey);
-        // 转换为 Signal Protocol 格式
-        // Signal Protocol 要求公钥带 0x05 前缀（33字节），私钥32字节
         const prefixedPublicKey = new Uint8Array(33);
-        prefixedPublicKey[0] = 0x05; // Signal Protocol 标准前缀
+        prefixedPublicKey[0] = 0x05;
         prefixedPublicKey.set(publicKey, 1);
         const signalIdentity = {
             privKey: privateKey.slice().buffer,
@@ -80,19 +54,10 @@ export class MessengerSession {
         };
         return this.identity;
     }
-    /**
-     * 从公钥确定性派生注册 ID
-     * 确保同一账户的注册 ID 始终相同
-     */
     deriveRegistrationId(publicKey) {
-        // 取公钥前 2 字节作为注册 ID（范围 0-65535）
-        // 确保不为 0（Signal Protocol 要求）
         const id = (publicKey[0] << 8) | publicKey[1];
         return id === 0 ? 1 : id;
     }
-    /**
-     * 注册设备到服务器
-     */
     async registerDevice(userAddress) {
         const identity = await this.ensureIdentity(userAddress);
         const signedPreKeyId = 1;
@@ -100,7 +65,6 @@ export class MessengerSession {
         let signedPreKeyPublicKey;
         let signedPreKeySignature;
         let isNewKey = false;
-        // 【关键修复】使用带签名的存储方法
         const existingSignedPreKey = await this.store.loadSignedPreKeyWithSignature(signedPreKeyId);
         if (existingSignedPreKey) {
             signedPreKeyPublicKey = arrayBufferToUint8Array(existingSignedPreKey.pubKey);
@@ -120,7 +84,6 @@ export class MessengerSession {
             signedPreKeySignature = arrayBufferToUint8Array(signedPreKey.signature);
             isNewKey = true;
         }
-        // 生成 One-Time PreKeys（暂不保存）
         const oneTimePrekeys = await this.generatePreKeyBatch(this.config.prekey_count, userAddress);
         const prefixedIdentityKey = arrayBufferToUint8Array(identity.signalIdentity.pubKey);
         const account = await (await getAccount()).get(userAddress, false);
@@ -155,25 +118,18 @@ export class MessengerSession {
         console.log(`[Session Debug] Verifying registration complete...`);
         await this.verifyRegistrationComplete(userAddress);
         console.log(`[Session Debug] Registration verification complete!`);
-        // 【关键修复】只有是新 key 时才保存到本地数据库（包含签名）
         if (isNewKey) {
             await this.store.storeSignedPreKeyWithSignature(signedPreKeyId, signedPreKey.keyPair, signedPreKeySignature.buffer.slice(0));
         }
     }
-    /**
-     * 验证注册是否完成
-     * 轮询检查服务器是否已存在该用户
-     */
     async verifyRegistrationComplete(userAddress, maxRetries = 10, retryDelay = 500) {
         for (let i = 0; i < maxRetries; i++) {
             try {
                 const status = await this.serverClient.getPrekeyStatus(userAddress);
-                // 如果成功获取状态，说明注册已完成
                 console.log(`Registration verified for ${userAddress}, prekeys: ${status.currentCount}/${status.maxAllowed}`);
                 return;
             }
             catch (error) {
-                // 如果是 404，说明注册还没完成，继续等待
                 if (error?.message?.includes("404") || error?.status === 404) {
                     if (i < maxRetries - 1) {
                         console.log(`Waiting for registration to complete... (${i + 1}/${maxRetries})`);
@@ -181,38 +137,27 @@ export class MessengerSession {
                         continue;
                     }
                 }
-                // 其他错误，抛出
                 throw error;
             }
         }
         throw new MessengerError(MessengerErrorCode.REGISTRATION_FAILED, `Registration verification failed after ${maxRetries} attempts`);
     }
-    /**
-     * 检查设备是否已在服务器上注册
-     * 通过查询服务器上的预密钥状态来判断
-     */
     async isDeviceRegistered(userAddress) {
         try {
-            // 检查本地是否有 signedPreKey（使用带签名的方法）
             const signedPreKey = await this.store.loadSignedPreKeyWithSignature(1);
             if (!signedPreKey) {
                 return false;
             }
-            // 尝试从服务器获取预密钥状态
             const _status = await this.serverClient.getPrekeyStatus(userAddress);
             return true;
         }
         catch (error) {
-            // 如果是 404，说明设备未注册
             if (error?.message?.includes("404") || error?.status === 404) {
                 return false;
             }
             return false;
         }
     }
-    /**
-     * 生成预密钥批次（One-Time PreKeys）
-     */
     async generatePreKeyBatch(count, userAddress) {
         if (count <= 0)
             return [];
@@ -249,9 +194,6 @@ export class MessengerSession {
         await this.store.setMeta({ nextPreKeyId });
         return prekeys;
     }
-    /**
-     * 确保服务器上有足够可用的预密钥
-     */
     async ensurePreKeys(userAddress, force = false) {
         const status = await this.serverClient.getPrekeyStatus(userAddress);
         if (!force && status.currentCount >= status.maxAllowed) {
@@ -285,17 +227,11 @@ export class MessengerSession {
             nonce,
         });
     }
-    /**
-     * 生成随机 nonce
-     */
     generateNonce() {
         const array = new Uint8Array(16);
         crypto.getRandomValues(array);
         return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
     }
-    /**
-     * 建立与对方的会话
-     */
     async establishSession(myAddress, peerAddress, peerDeviceId = DEFAULT_DEVICE_ID, remoteBundle) {
         const protocolAddress = new SignalProtocolAddress(peerAddress, peerDeviceId);
         const existingSession = await this.store.loadSession(protocolAddress.toString());
@@ -356,7 +292,6 @@ export class MessengerSession {
         const builder = new SessionBuilder(this.store, protocolAddress);
         await builder.processPreKey(device);
         await this.store.saveIdentity(protocolAddress.toString(), device.identityKey);
-        // 【关键改进】将会话从默认key复制到发送会话key
         const defaultSessionKey = protocolAddress.toString();
         const sendSessionKey = `send:${peerAddress}.${peerDeviceId}`;
         const sessionData = await this.store.loadSession(defaultSessionKey);
@@ -365,31 +300,19 @@ export class MessengerSession {
             console.log(`[Session] 会话已保存到发送key: ${sendSessionKey}`);
         }
     }
-    /**
-     * 加密消息
-     * 【改进】使用发送会话key，与接收会话分离
-     */
     async encryptMessage(myAddress, peerAddress, plaintext, peerDeviceId = DEFAULT_DEVICE_ID) {
         const protocolAddress = new SignalProtocolAddress(peerAddress, peerDeviceId);
-        // Signal Protocol使用的默认key格式
         const defaultSessionKey = protocolAddress.toString();
-        // 【关键改进】使用发送会话key
         const sendSessionKey = `send:${peerAddress}.${peerDeviceId}`;
         const recvSessionKey = `recv:${peerAddress}.${peerDeviceId}`;
-        // 【关键】首先检查默认key（Signal Protocol使用的格式）
         let existingDefaultSession = await this.store.loadSession(defaultSessionKey);
-        // 检查是否存在发送会话或接收会话
         let existingSendSession = await this.store.loadSession(sendSessionKey);
         const existingRecvSession = await this.store.loadSession(recvSessionKey);
-        // 【关键逻辑1】如果存在接收会话但没有默认会话，复制接收会话到默认key
-        // 这样SessionCipher可以找到会话
         if (!existingDefaultSession && existingRecvSession) {
             console.log(`[Session] 复制接收会话到默认key: ${peerAddress}`);
             await this.store.storeSession(defaultSessionKey, existingRecvSession);
             existingDefaultSession = existingRecvSession;
         }
-        // 【关键逻辑2】如果存在接收会话但没有发送会话，复制接收会话作为发送会话
-        // 这确保双方使用相同的密钥材料
         if (!existingSendSession && existingRecvSession) {
             console.log(`[Session] 复制接收会话到发送会话: ${peerAddress}`);
             await this.store.storeSession(sendSessionKey, existingRecvSession);
@@ -398,7 +321,7 @@ export class MessengerSession {
         let existingSession = existingDefaultSession || existingSendSession;
         let isNewSession = !existingSession;
         let retryCount = 0;
-        const maxRetries = 5; // 【用户要求】加大容错窗口，让消息可以重试更多次
+        const maxRetries = 5;
         while (retryCount <= maxRetries) {
             try {
                 if (isNewSession) {
@@ -449,7 +372,6 @@ export class MessengerSession {
                 console.log(`[Session] 尝试删除旧会话并重新建立...`);
                 try {
                     if (existingSession) {
-                        // 【关键】删除所有相关的会话key
                         await this.store.removeSession(defaultSessionKey);
                         await this.store.removeSession(sendSessionKey);
                         await this.store.removeSession(recvSessionKey);
@@ -467,9 +389,6 @@ export class MessengerSession {
         }
         throw new MessengerError(MessengerErrorCode.ENCRYPTION_FAILED, "Encryption failed after multiple attempts");
     }
-    /**
-     * 解密消息
-     */
     async decryptMessage(myAddress, peerAddress, ciphertext, msgType, peerDeviceId = DEFAULT_DEVICE_ID) {
         const protocolAddress = new SignalProtocolAddress(peerAddress, peerDeviceId);
         const sessionKey = protocolAddress.toString();
@@ -481,8 +400,7 @@ export class MessengerSession {
             ciphertextBinary += String.fromCharCode(ciphertextArray[i]);
         }
         let retryCount = 0;
-        const maxRetries = 5; // 【用户要求】加大容错窗口，让消息可以重试更多次
-        // 【新增】如果是 WHISPER_MESSAGE 且没有现有会话，直接抛出可重试错误
+        const maxRetries = 5;
         if (msgType !== MessageType.PREKEY_MESSAGE && !existingSession) {
             console.log(`[Session] 收到 WHISPER_MESSAGE 但无现有会话，需要等待 PREKEY_MESSAGE`);
             throw new Error("收到 WHISPER_MESSAGE 但无现有会话，需要等待 PREKEY_MESSAGE");
@@ -494,7 +412,6 @@ export class MessengerSession {
                 if (msgType === MessageType.PREKEY_MESSAGE) {
                     console.log(`[Session] 收到 PREKEY_MESSAGE，尝试解密 (尝试 ${retryCount + 1}/${maxRetries + 1})`);
                     try {
-                        // 【用户要求】先用尝试解密（真解密可能推动会话密钥变更，极度重要！）
                         plaintextBuffer =
                             await cipher.decryptPreKeyWhisperMessage(ciphertextBinary, "binary");
                         console.log(`[Session] PREKEY_MESSAGE 解密成功！`);
@@ -502,22 +419,17 @@ export class MessengerSession {
                     }
                     catch (decryptError) {
                         console.log(`[Session] 直接解密 PREKEY_MESSAGE 失败: ${decryptError instanceof Error ? decryptError.message : String(decryptError)}`);
-                        // 如果解密失败，再处理 PREKEY 竞争的情况（但只在第一次尝试时处理）
                         if (existingSession && retryCount === 0) {
-                            // 【用户要求】PREKEY 竞争时，双方始终优先以小地址发送的消息为最终依据
                             const myAddr = myAddress.toLowerCase();
                             const peerAddr = peerAddress.toLowerCase();
                             if (myAddr < peerAddr) {
-                                // 我的地址较小，保留我的会话！不处理这个 PREKEY_MESSAGE，稍后重试
                                 console.log(`[Session] 我的地址较小 (${myAddr} < ${peerAddr})，保留我的会话，稍后重试`);
                                 throw new Error("PREKEY 竞争：我的地址较小，保留我的会话");
                             }
                             else {
-                                // 我的地址较大，删除我的会话，用对方的 PREKEY_MESSAGE 建立新会话
                                 console.log(`[Session] 我的地址较大 (${myAddr} > ${peerAddr})，删除我的会话，用对方的 PREKEY_MESSAGE 建立新会话`);
                                 await this.store.removeSession(sessionKey);
                                 existingSession = undefined;
-                                // 现在删除了会话，重新尝试解密
                                 console.log(`[Session] 已删除旧会话，重新尝试解密...`);
                                 plaintextBuffer =
                                     await cipher.decryptPreKeyWhisperMessage(ciphertextBinary, "binary");
@@ -526,7 +438,6 @@ export class MessengerSession {
                             }
                         }
                         else {
-                            // 没有现有会话，或者不是第一次尝试，重新抛出解密错误
                             throw decryptError;
                         }
                     }
@@ -581,16 +492,10 @@ export class MessengerSession {
         }
         throw new MessengerError(MessengerErrorCode.DECRYPTION_FAILED, "Decryption failed after multiple attempts");
     }
-    /**
-     * 获取本地身份公钥
-     */
     async getIdentityKey() {
         const identity = await this.ensureIdentity();
         return bytesToBase64(arrayBufferToUint8Array(identity.signalIdentity.pubKey));
     }
-    /**
-     * 获取注册 ID
-     */
     async getRegistrationId() {
         const identity = await this.ensureIdentity();
         return identity.registrationId;
@@ -601,9 +506,6 @@ export class SessionStateManager {
     constructor(store) {
         this.store = store;
     }
-    /**
-     * 保存会话快照
-     */
     async snapshotSession(sessionKey) {
         const sessionData = await this.store.loadSession(sessionKey);
         return {
@@ -611,9 +513,6 @@ export class SessionStateManager {
             timestamp: Date.now(),
         };
     }
-    /**
-     * 回滚会话状态
-     */
     async rollbackSession(sessionKey, snapshot) {
         if (snapshot.sessionData) {
             await this.store.storeSession(sessionKey, snapshot.sessionData);
@@ -624,12 +523,7 @@ export class SessionStateManager {
             console.log(`[SessionState] 清除会话: ${sessionKey}`);
         }
     }
-    /**
-     * 提交会话状态（保留新会话）
-     */
     async commitSession(_sessionKey) {
-        // 新会话已经在 decrypt 过程中保存到存储
-        // 这里可以添加额外的确认逻辑
         console.log(`[SessionState] 提交新会话`);
     }
 }
@@ -640,30 +534,15 @@ export class DecryptionEngine {
         this.store = store;
         this.sessionManager = new SessionStateManager(store);
     }
-    /**
-     * 【核心改进】获取接收会话key
-     * 使用 recv: 前缀区分接收会话和发送会话
-     */
     getRecvSessionKey(peerAddress, deviceId) {
         return `recv:${peerAddress}.${deviceId}`;
     }
-    /**
-     * 【核心改进】获取发送会话key
-     * 使用 send: 前缀区分发送会话和接收会话
-     */
     getSendSessionKey(peerAddress, deviceId) {
         return `send:${peerAddress}.${deviceId}`;
     }
-    /**
-     * 统一解密入口
-     * 【改进】使用方向区分的sessionKey管理双向会话
-     */
     async decryptMessage(myAddress, peerAddress, ciphertext, msgType, peerDeviceId = DEFAULT_DEVICE_ID) {
-        // 【关键改进】使用接收会话key
         const recvSessionKey = this.getRecvSessionKey(peerAddress, peerDeviceId);
-        // 创建protocolAddress用于Signal Protocol
         const protocolAddress = new SignalProtocolAddress(peerAddress, peerDeviceId);
-        // 1. 保存会话快照（用于回滚）
         const snapshot = await this.sessionManager.snapshotSession(recvSessionKey);
         try {
             if (msgType === MessageType.PREKEY_MESSAGE) {
@@ -674,7 +553,6 @@ export class DecryptionEngine {
             }
         }
         catch (error) {
-            // 发生错误，回滚会话
             await this.sessionManager.rollbackSession(recvSessionKey, snapshot);
             return {
                 success: false,
@@ -687,32 +565,21 @@ export class DecryptionEngine {
             };
         }
     }
-    /**
-     * 处理 PREKEY_MESSAGE
-     * 【核心改进】无论大小地址，都保存接收会话
-     * 小地址优先原则只影响发送会话，不影响接收会话
-     */
     async handlePreKeyMessage(myAddress, peerAddress, ciphertext, protocolAddress, recvSessionKey, snapshot) {
         console.log(`[Decrypt] 处理 PREKEY_MESSAGE from ${peerAddress}`);
         const cipher = new SessionCipher(this.store, protocolAddress);
         const decoder = new TextDecoder();
-        // 尝试解密（这会可能建立新会话）
         const ciphertextBinary = this.arrayBufferToBinary(ciphertext);
         const plaintextBuffer = await cipher.decryptPreKeyWhisperMessage(ciphertextBinary, "binary");
         const plaintext = decoder.decode(plaintextBuffer);
         console.log(`[Decrypt] PREKEY_MESSAGE 解密成功`);
-        // 【核心改进】无论大小地址，都保存接收会话
-        // 因为PREKEY_MESSAGE意味着对方想要建立会话，我们应该接受
         await this.sessionManager.commitSession(recvSessionKey);
         const myAddr = myAddress.toLowerCase();
         const peerAddr = peerAddress.toLowerCase();
         if (myAddr < peerAddr) {
-            // 我是小地址，我的发送会话优先
-            // 但接收会话仍然保存（用于解密对方的消息）
             console.log(`[Decrypt] 小地址(${myAddr})保存接收会话用于解密，发送会话保持不变`);
         }
         else {
-            // 我是大地址，完全接受对方的会话
             console.log(`[Decrypt] 大地址(${myAddr})接受新会话`);
         }
         return {
@@ -723,13 +590,8 @@ export class DecryptionEngine {
             messageType: "PREKEY",
         };
     }
-    /**
-     * 处理 WHISPER_MESSAGE
-     * 【改进】使用接收会话key查找会话
-     */
     async handleWhisperMessage(_myAddress, peerAddress, ciphertext, protocolAddress, recvSessionKey, snapshot) {
         console.log(`[Decrypt] 处理 WHISPER_MESSAGE from ${peerAddress}`);
-        // 【改进】检查接收会话是否存在
         const existingSession = await this.store.loadSession(recvSessionKey);
         if (!existingSession) {
             console.log(`[Decrypt] 无接收会话，WHISPER_MESSAGE 需要等待 PREKEY`);
@@ -744,7 +606,6 @@ export class DecryptionEngine {
         }
         const cipher = new SessionCipher(this.store, protocolAddress);
         const decoder = new TextDecoder();
-        // 尝试解密
         const ciphertextBinary = this.arrayBufferToBinary(ciphertext);
         const plaintextBuffer = await cipher.decryptWhisperMessage(ciphertextBinary, "binary");
         console.log(`[Decrypt] WHISPER_MESSAGE 解密成功`);
@@ -765,4 +626,3 @@ export class DecryptionEngine {
         return binary;
     }
 }
-//# sourceMappingURL=session.js.map

package/dist/cjs/w/messenger/storage.d.ts

@@ -19,18 +19,10 @@ interface StorageType {
     storeSession(encodedAddress: string, record: string): Promise<void>;
     removeSession(encodedAddress: string): Promise<void>;
 }
-/**
- * 重置数据库连接
- * 用于测试时清理数据后重新创建连接
- */
 export declare function resetDbConnection(): void;
 interface PersistedMeta {
     nextPreKeyId: number;
 }
-/**
- * Signal Protocol SQLite 存储
- * 兼容 libsignal-protocol-typescript 的 StorageType 接口
- */
 export declare class SignalProtocolStorage implements StorageType {
     private storePrefix;
     private userAddress;
@@ -52,20 +44,8 @@ export declare class SignalProtocolStorage implements StorageType {
         signature: ArrayBuffer;
     }) | undefined>;
     storeSignedPreKeyWithSignature(keyId: string | number, keyPair: KeyPairType, signature: ArrayBuffer): Promise<void>;
-    /**
-     * 【核心改进】加载会话，支持发送/接收会话映射
-     * encodedAddress 格式: "peerAddress.deviceId"
-     * 我们会同时检查默认key和带前缀的key
-     */
     loadSession(encodedAddress: string): Promise<string | undefined>;
-    /**
-     * 【关键修复】保存会话时，如果是默认key格式，同时保存到接收会话key
-     * 这样Signal Protocol的SessionCipher保存的会话可以被我们的recv:key找到
-     */
     storeSession(encodedAddress: string, record: string): Promise<void>;
-    /**
-     * 【关键修复】删除会话时，同时删除对应的recv:key
-     */
     removeSession(encodedAddress: string): Promise<void>;
     getMeta(): Promise<PersistedMeta>;
     setMeta(meta: Partial<PersistedMeta>): Promise<void>;
@@ -83,59 +63,12 @@ export declare class MessageStorage {
     getMessagesBySession(myAddress: string, peerAddress: string): Message[];
     getPendingMessages(myAddress: string): Message[];
     updateMessageStatus(messageId: string, status: Message["status"], updates?: Partial<Message>): void;
-    /**
-     * 更新消息查看状态
-     * 将消息标记为已查看，设置 viewed_at 为当前时间戳
-     *
-     * @param messageId 消息 ID
-     * @param viewedAt 查看时间戳（可选，默认当前时间）
-     * @returns 是否更新成功
-     */
     updateMessageViewed(messageId: string, viewedAt?: number): boolean;
-    /**
-     * 批量更新消息查看状态
-     *
-     * @param messageIds 消息 ID 列表
-     * @param viewedAt 查看时间戳（可选，默认当前时间）
-     * @returns 成功更新的消息数量
-     */
     updateMessagesViewed(messageIds: string[], viewedAt?: number): number;
-    /**
-     * 获取用户的所有消息
-     *
-     * @param userAddress 用户地址
-     * @returns 所有相关消息（发送和接收的）
-     */
     getAllMessages(userAddress: string): Message[];
-    /**
-     * 通过消息 ID 获取消息
-     *
-     * @param messageId 消息 ID
-     * @returns 消息对象或 undefined
-     */
     getMessageById(messageId: string): Message | undefined;
-    /**
-     * 更新消息 ID（用于 Guard 消息确认后更新 messageId）
-     *
-     * 由于 message_id 是主键，需要通过删除旧记录并插入新记录来实现
-     *
-     * @param oldMessageId 旧消息 ID（internal_id）
-     * @param newMessageId 新消息 ID（正式的 message_id）
-     * @param updates 可选的更新字段
-     * @returns 是否成功更新
-     */
     updateMessageId(oldMessageId: string, newMessageId: string, updates?: Partial<Message>): boolean;
     private rowToMessage;
-    /**
-     * 获取最后收到的消息序号（用于消息同步确认）
-     *
-     * 查询指定会话中，用户作为接收者时，发送者最后收到的消息序号
-     * 用于在发送新消息时，告诉对方我已经收到了哪些消息
-     *
-     * @param myAddress 当前用户地址
-     * @param peerAddress 对方地址
-     * @returns 最后收到的消息序号（leafIndex），如果没有则返回 -1
-     */
     getLastReceivedLeafIndex(myAddress: string, peerAddress: string): number;
 }
 export declare class SessionStateStorage {
@@ -148,103 +81,27 @@ export declare class SessionStateStorage {
     getCurrentRoot(myAddress: string, peerAddress: string): string;
 }
 export interface PersistedMessengerState {
-    /** 版本 */
     version: string;
-    /** 管理的账号列表（名称或地址） */
     accounts: string[];
-    /** Messenger 配置 */
     config: Partial<MessengerConfig>;
-    /** 最后更新时间 */
     updatedAt: number;
 }
-/**
- * MessengerManager 持久化存储类
- *
- * 使用 SQLite 存储 MessengerManager 的配置和状态
- */
 export declare class MessengerPersistStorage {
     private initialized;
     private get db();
-    /**
-     * 初始化存储表
-     */
     private initTable;
-    /**
-     * 保存 Messenger 配置和账号信息
-     *
-     * @param instanceId 实例标识（用于区分不同的 MessengerManager 实例）
-     * @param state 要保存的状态
-     */
     saveState(instanceId: string, state: PersistedMessengerState): void;
-    /**
-     * 加载 Messenger 配置和账号信息
-     *
-     * @param instanceId 实例标识
-     * @returns 保存的状态，如果不存在返回 null
-     */
     loadState(instanceId: string): PersistedMessengerState | null;
-    /**
-     * 删除保存的状态
-     *
-     * @param instanceId 实例标识
-     */
     deleteState(instanceId: string): void;
-    /**
-     * 获取所有实例ID列表
-     */
     getAllInstanceIds(): string[];
     private get processId();
-    /**
-     * 尝试获取指定账号的 SSE 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否成功获取锁
-     */
     tryAcquireSSELock(accountAddress: string, instanceId: string): boolean;
-    /**
-     * 更新 SSE 连接锁的心跳
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     updateSSELockHeartbeat(accountAddress: string, instanceId: string): void;
-    /**
-     * 释放指定账号的 SSE 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     releaseSSELock(accountAddress: string, instanceId: string): void;
-    /**
-     * 检查是否持有指定账号的 SSE 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否持有锁
-     */
     holdsSSELock(accountAddress: string, instanceId: string): boolean;
-    /**
-     * 尝试获取指定账号的 Polling 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否成功获取锁
-     */
     tryAcquirePollingLock(accountAddress: string, instanceId: string): boolean;
-    /**
-     * 更新 Polling 连接锁的心跳
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     updatePollingLockHeartbeat(accountAddress: string, instanceId: string): void;
-    /**
-     * 释放指定账号的 Polling 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     */
     releasePollingLock(accountAddress: string, instanceId: string): void;
-    /**
-     * 检查是否持有指定账号的 Polling 连接锁
-     * @param accountAddress 账号地址
-     * @param instanceId 当前实例ID
-     * @returns 是否持有锁
-     */
     holdsPollingLock(accountAddress: string, instanceId: string): boolean;
 }
 export declare const defaultPersistStorage: MessengerPersistStorage;