wowok 1.8.2 → 2.1.9

package/dist/esm/w/messenger/session.d.ts

@@ -0,0 +1,78 @@
+import type { Xed25519KeyPair, MessengerConfig } from "./types.js";
+type KeyPairType = {
+    pubKey: ArrayBuffer;
+    privKey: ArrayBuffer;
+};
+export interface LocalIdentity {
+    xed25519: Xed25519KeyPair;
+    signalIdentity: KeyPairType;
+    registrationId: number;
+}
+export interface EncryptedMessage {
+    type: number;
+    body: ArrayBuffer;
+    registrationId?: number;
+}
+export declare class MessengerSession {
+    private store;
+    private serverClient;
+    private config;
+    private identity;
+    constructor(userAddress: string, config?: Partial<MessengerConfig>);
+    /**
+     * 获取或创建本地身份
+     *
+     * 从 wowok 账户的 ED25519 私钥确定性派生 X25519 密钥对，
+     * 确保恢复钱包后加密身份不变。
+     */
+    ensureIdentity(userAddress?: string): Promise<LocalIdentity>;
+    /**
+     * 从公钥确定性派生注册 ID
+     * 确保同一账户的注册 ID 始终相同
+     */
+    private deriveRegistrationId;
+    /**
+     * 注册设备到服务器
+     */
+    registerDevice(userAddress: string): Promise<void>;
+    /**
+     * 生成预密钥批次
+     */
+    private generatePreKeyBatch;
+    /**
+     * 确保服务器上有足够可用的预密钥
+     *
+     * 逻辑：查询服务器当前预密钥数量，按需生成并上传，补充到服务器最大容量
+     */
+    ensurePreKeys(userAddress: string, force?: boolean): Promise<void>;
+    /**
+     * 生成随机 nonce
+     */
+    private generateNonce;
+    /**
+     * 建立与对方的会话
+     */
+    establishSession(myAddress: string, peerAddress: string, peerDeviceId?: number): Promise<void>;
+    /**
+     * 加密消息
+     * @param myAddress 发送方地址
+     * @param peerAddress 接收方地址
+     * @param plaintext 明文
+     * @param peerDeviceId 设备ID
+     * @returns 加密后的消息（type 表示底层 Signal Protocol 消息类型：3=PreKeyMessage, 1=WhisperMessage）
+     */
+    encryptMessage(myAddress: string, peerAddress: string, plaintext: string, peerDeviceId?: number): Promise<EncryptedMessage>;
+    /**
+     * 解密消息
+     */
+    decryptMessage(myAddress: string, peerAddress: string, ciphertext: ArrayBuffer, msgType: number, peerDeviceId?: number): Promise<string>;
+    /**
+     * 获取本地身份公钥
+     */
+    getIdentityKey(): Promise<string>;
+    /**
+     * 获取注册 ID
+     */
+    getRegistrationId(): Promise<number>;
+}
+export {};

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

@@ -0,0 +1,415 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  KeyHelper,
+  SessionBuilder,
+  SessionCipher,
+  SignalProtocolAddress
+} from "libsignal-protocol-typescript";
+import { Account } from "../local/account.js";
+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";
+class MessengerSession {
+  constructor(userAddress, config) {
+    __publicField(this, "store");
+    __publicField(this, "serverClient");
+    __publicField(this, "config");
+    __publicField(this, "identity", null);
+    this.store = new SignalProtocolStorage(userAddress);
+    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) {
+      const x25519PrivateKey = new Uint8Array(
+        existingSignalIdentity.privKey
+      );
+      const xed255192 = recoverXed25519FromX25519PrivateKey(x25519PrivateKey);
+      this.identity = {
+        xed25519: xed255192,
+        signalIdentity: existingSignalIdentity,
+        registrationId: existingRegId
+      };
+      return this.identity;
+    }
+    if (!userAddress) {
+      throw new MessengerError(
+        MessengerErrorCode.IDENTITY_NOT_FOUND,
+        "userAddress is required to derive identity"
+      );
+    }
+    const { privateKey, publicKey } = await Account.Instance().deriveX25519KeyPair(userAddress);
+    const registrationId = this.deriveRegistrationId(publicKey);
+    const prefixedPublicKey = new Uint8Array(33);
+    prefixedPublicKey[0] = 5;
+    prefixedPublicKey.set(publicKey, 1);
+    const signalIdentity = {
+      privKey: privateKey.buffer.slice(
+        privateKey.byteOffset,
+        privateKey.byteOffset + privateKey.byteLength
+      ),
+      pubKey: prefixedPublicKey.buffer.slice(
+        prefixedPublicKey.byteOffset,
+        prefixedPublicKey.byteOffset + prefixedPublicKey.byteLength
+      )
+    };
+    await this.store.setIdentity(signalIdentity, registrationId);
+    const xed25519 = recoverXed25519FromX25519PrivateKey(privateKey);
+    this.identity = {
+      xed25519,
+      signalIdentity,
+      registrationId
+    };
+    return this.identity;
+  }
+  /**
+   * 从公钥确定性派生注册 ID
+   * 确保同一账户的注册 ID 始终相同
+   */
+  deriveRegistrationId(publicKey) {
+    const id = publicKey[0] << 8 | publicKey[1];
+    return id === 0 ? 1 : id;
+  }
+  /**
+   * 注册设备到服务器
+   */
+  async registerDevice(userAddress) {
+    const identity = await this.ensureIdentity(userAddress);
+    const prekeys = await this.generatePreKeyBatch(
+      this.config.prekey_count
+    );
+    const prefixedIdentityKey = arrayBufferToUint8Array(
+      identity.signalIdentity.pubKey
+    );
+    const account = await Account.Instance().get(userAddress, false);
+    if (!account?.pubkey) {
+      throw new MessengerError(
+        MessengerErrorCode.IDENTITY_NOT_FOUND,
+        `Account not found for ${userAddress}`
+      );
+    }
+    const timestamp = Date.now();
+    const nonce = this.generateNonce();
+    const message = `register:${account.pubkey}:${timestamp}:${nonce}`;
+    const signResult = await Account.Instance().signData(
+      userAddress,
+      message
+    );
+    const signature = Buffer.from(signResult.signature.slice(2), "hex");
+    const registerRequest = {
+      userAddress,
+      deviceId: DEFAULT_DEVICE_ID,
+      registrationId: identity.registrationId,
+      identityKey: bytesToBase64(prefixedIdentityKey),
+      prekeys,
+      publicKey: account.pubkey,
+      signatureScheme: "ED25519",
+      signature: bytesToBase64(signature),
+      timestamp,
+      nonce
+    };
+    await this.serverClient.registerDevice(registerRequest);
+  }
+  /**
+   * 生成预密钥批次
+   */
+  async generatePreKeyBatch(count) {
+    if (count <= 0) return [];
+    const identity = await this.ensureIdentity();
+    const meta = await this.store.getMeta();
+    let nextPreKeyId = meta.nextPreKeyId || 1;
+    const prekeys = [];
+    for (let i = 0; i < count; i++) {
+      const keyId = nextPreKeyId + i;
+      const signedPreKey = await KeyHelper.generateSignedPreKey(
+        identity.signalIdentity,
+        keyId
+      );
+      const prekeyPublicKey = arrayBufferToUint8Array(
+        signedPreKey.keyPair.pubKey
+      );
+      const prefixedPublicKey = prekeyPublicKey;
+      const signature = arrayBufferToUint8Array(signedPreKey.signature);
+      await this.store.storePreKey(keyId, signedPreKey.keyPair);
+      await this.store.storeSignedPreKey(keyId, signedPreKey.keyPair);
+      prekeys.push({
+        keyId,
+        publicKey: bytesToBase64(prefixedPublicKey),
+        signature: bytesToBase64(signature)
+      });
+    }
+    nextPreKeyId += count;
+    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) {
+      throw new MessengerError(
+        MessengerErrorCode.PREKEYS_FULL,
+        `Prekeys already full on server: ${status.currentCount}/${status.maxAllowed}`
+      );
+    }
+    const needCount = status.maxAllowed - status.currentCount;
+    if (needCount <= 0) {
+      return;
+    }
+    await this.ensureIdentity(userAddress);
+    const prekeys = await this.generatePreKeyBatch(needCount);
+    const account = await Account.Instance().get(userAddress, false);
+    if (!account?.pubkey) {
+      throw new MessengerError(
+        MessengerErrorCode.IDENTITY_NOT_FOUND,
+        `Account not found for ${userAddress}`
+      );
+    }
+    const timestamp = Date.now();
+    const nonce = this.generateNonce();
+    const message = `upload_prekeys:${account.pubkey}:${timestamp}:${nonce}`;
+    const signResult = await Account.Instance().signData(
+      userAddress,
+      message
+    );
+    const signature = Buffer.from(signResult.signature.slice(2), "hex");
+    await this.serverClient.uploadPreKeys({
+      userAddress,
+      prekeys,
+      publicKey: account.pubkey,
+      signatureScheme: "ED25519",
+      signature: bytesToBase64(signature),
+      timestamp,
+      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) {
+    const protocolAddress = new SignalProtocolAddress(
+      peerAddress,
+      peerDeviceId
+    );
+    const existingSession = await this.store.loadSession(
+      protocolAddress.toString()
+    );
+    if (existingSession) {
+      return;
+    }
+    const account = await Account.Instance().get(myAddress, false);
+    if (!account?.pubkey) {
+      throw new MessengerError(
+        MessengerErrorCode.IDENTITY_NOT_FOUND,
+        `Account not found for ${myAddress}`
+      );
+    }
+    const timestamp = Date.now();
+    const nonce = this.generateNonce();
+    const publicKeyWithFlag = account.pubkey;
+    const message = `get_bundle:${myAddress}:${timestamp}:${nonce}`;
+    const signResult = await Account.Instance().signData(
+      myAddress,
+      message
+    );
+    const signature = Buffer.from(signResult.signature.slice(2), "hex");
+    const remoteBundle = await this.serverClient.fetchRemoteBundle(
+      peerAddress,
+      myAddress,
+      publicKeyWithFlag,
+      {
+        signatureScheme: "ED25519",
+        signature: bytesToBase64(new Uint8Array(signature)),
+        timestamp,
+        nonce
+      },
+      peerDeviceId
+    );
+    const preferredPreKey = remoteBundle.signedPrekey;
+    if (!preferredPreKey) {
+      throw new MessengerError(
+        MessengerErrorCode.IDENTITY_NOT_FOUND,
+        `No signed prekey available for ${peerAddress}`
+      );
+    }
+    const identityKeyBytes = base64ToBytes(remoteBundle.identityKey);
+    const preKeyPublicBytes = base64ToBytes(preferredPreKey.publicKey);
+    const signatureBytes = base64ToBytes(preferredPreKey.signature);
+    const originalIdentityKeyWithPrefix = new Uint8Array(identityKeyBytes);
+    const originalPreKeyWithPrefix = new Uint8Array(preKeyPublicBytes);
+    const device = {
+      registrationId: remoteBundle.registrationId,
+      identityKey: originalIdentityKeyWithPrefix.buffer.slice(
+        originalIdentityKeyWithPrefix.byteOffset,
+        originalIdentityKeyWithPrefix.byteOffset + originalIdentityKeyWithPrefix.byteLength
+      ),
+      signedPreKey: {
+        keyId: preferredPreKey.keyId,
+        publicKey: originalPreKeyWithPrefix.buffer.slice(
+          originalPreKeyWithPrefix.byteOffset,
+          originalPreKeyWithPrefix.byteOffset + originalPreKeyWithPrefix.byteLength
+        ),
+        signature: new Uint8Array(signatureBytes).buffer.slice(
+          signatureBytes.byteOffset,
+          signatureBytes.byteOffset + signatureBytes.byteLength
+        )
+      },
+      // 服务器只提供 signedPreKey，没有单独的 one-time preKey
+      // 这是可以的，Signal Protocol 支持仅使用 signedPreKey 建立会话
+      preKey: void 0
+    };
+    const builder = new SessionBuilder(this.store, protocolAddress);
+    await builder.processPreKey(device);
+    await this.store.saveIdentity(
+      protocolAddress.toString(),
+      device.identityKey
+    );
+  }
+  /**
+   * 加密消息
+   * @param myAddress 发送方地址
+   * @param peerAddress 接收方地址
+   * @param plaintext 明文
+   * @param peerDeviceId 设备ID
+   * @returns 加密后的消息（type 表示底层 Signal Protocol 消息类型：3=PreKeyMessage, 1=WhisperMessage）
+   */
+  async encryptMessage(myAddress, peerAddress, plaintext, peerDeviceId = DEFAULT_DEVICE_ID) {
+    const protocolAddress = new SignalProtocolAddress(
+      peerAddress,
+      peerDeviceId
+    );
+    const sessionKey = protocolAddress.toString();
+    const existingSession = await this.store.loadSession(sessionKey);
+    const isNewSession = !existingSession;
+    if (isNewSession) {
+      await this.establishSession(myAddress, peerAddress, peerDeviceId);
+    }
+    const cipher = new SessionCipher(this.store, protocolAddress);
+    const encoder = new TextEncoder();
+    const cipherMessage = await cipher.encrypt(
+      encoder.encode(plaintext).buffer
+    );
+    let bodyBuffer;
+    if (typeof cipherMessage.body === "string") {
+      const bodyBytes = Buffer.from(cipherMessage.body, "binary");
+      bodyBuffer = new Uint8Array(bodyBytes).buffer;
+    } else if (cipherMessage.body) {
+      bodyBuffer = cipherMessage.body;
+    } else {
+      throw new MessengerError(
+        MessengerErrorCode.ENCRYPTION_FAILED,
+        "Cipher message body is empty"
+      );
+    }
+    return {
+      type: cipherMessage.type,
+      body: bodyBuffer,
+      registrationId: cipherMessage.registrationId
+    };
+  }
+  /**
+   * 解密消息
+   */
+  async decryptMessage(myAddress, peerAddress, ciphertext, msgType, peerDeviceId = DEFAULT_DEVICE_ID) {
+    const protocolAddress = new SignalProtocolAddress(
+      peerAddress,
+      peerDeviceId
+    );
+    const cipher = new SessionCipher(this.store, protocolAddress);
+    const decoder = new TextDecoder();
+    const sessionKey = protocolAddress.toString();
+    const existingSession = await this.store.loadSession(sessionKey);
+    let plaintextBuffer;
+    const ciphertextArray = new Uint8Array(ciphertext);
+    let ciphertextBinary = "";
+    for (let i = 0; i < ciphertextArray.length; i++) {
+      ciphertextBinary += String.fromCharCode(ciphertextArray[i]);
+    }
+    try {
+      if (msgType === MessageType.PREKEY_MESSAGE) {
+        if (existingSession) {
+          await this.store.removeSession(sessionKey);
+          const newCipher = new SessionCipher(
+            this.store,
+            protocolAddress
+          );
+          plaintextBuffer = await newCipher.decryptPreKeyWhisperMessage(
+            ciphertextBinary,
+            "binary"
+          );
+        } else {
+          plaintextBuffer = await cipher.decryptPreKeyWhisperMessage(
+            ciphertextBinary,
+            "binary"
+          );
+        }
+      } else {
+        plaintextBuffer = await cipher.decryptWhisperMessage(
+          ciphertextBinary,
+          "binary"
+        );
+      }
+    } catch (error) {
+      console.log("error:", error);
+      throw error;
+    }
+    return decoder.decode(plaintextBuffer);
+  }
+  /**
+   * 获取本地身份公钥
+   */
+  async getIdentityKey() {
+    const identity = await this.ensureIdentity();
+    return bytesToBase64(
+      arrayBufferToUint8Array(identity.signalIdentity.pubKey)
+    );
+  }
+  /**
+   * 获取注册 ID
+   */
+  async getRegistrationId() {
+    const identity = await this.ensureIdentity();
+    return identity.registrationId;
+  }
+}
+export {
+  MessengerSession
+};

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

@@ -0,0 +1,192 @@
+import type { Message, SessionState, MessengerConfig } from "./types.js";
+type KeyPairType = {
+    pubKey: ArrayBuffer;
+    privKey: ArrayBuffer;
+};
+interface StorageType {
+    getIdentityKeyPair(): Promise<KeyPairType | undefined>;
+    getLocalRegistrationId(): Promise<number | undefined>;
+    isTrustedIdentity(identifier: string, identityKey: ArrayBuffer, direction?: number): Promise<boolean>;
+    saveIdentity(encodedAddress: string, publicKey: ArrayBuffer): Promise<boolean>;
+    loadIdentity(address: string): Promise<ArrayBuffer | undefined>;
+    loadPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+    storePreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+    removePreKey(keyId: string | number): Promise<void>;
+    loadSignedPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+    storeSignedPreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+    removeSignedPreKey(keyId: string | number): Promise<void>;
+    loadSession(encodedAddress: string): Promise<string | undefined>;
+    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;
+    constructor(userAddress: string, storeType?: string);
+    private get db();
+    setIdentity(identity: KeyPairType, registrationId: number): Promise<void>;
+    getIdentityKeyPair(): Promise<KeyPairType | undefined>;
+    getLocalRegistrationId(): Promise<number | undefined>;
+    isTrustedIdentity(identifier: string, identityKey: ArrayBuffer): Promise<boolean>;
+    saveIdentity(encodedAddress: string, publicKey: ArrayBuffer): Promise<boolean>;
+    loadIdentity(address: string): Promise<ArrayBuffer | undefined>;
+    loadPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+    storePreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+    removePreKey(keyId: string | number): Promise<void>;
+    loadSignedPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+    storeSignedPreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+    removeSignedPreKey(keyId: string | number): Promise<void>;
+    loadSession(encodedAddress: string): Promise<string | undefined>;
+    storeSession(encodedAddress: string, record: string): Promise<void>;
+    removeSession(encodedAddress: string): Promise<void>;
+    getMeta(): Promise<PersistedMeta>;
+    setMeta(meta: Partial<PersistedMeta>): Promise<void>;
+    listPreKeys(): number[];
+    private getValue;
+    private putValue;
+    private delValue;
+}
+export declare class MessageStorage {
+    private userAddress;
+    constructor(userAddress: string);
+    private get db();
+    saveMessage(message: Message): void;
+    getMessage(messageId: string): Message | undefined;
+    getMessagesBySession(myAddress: string, peerAddress: string): Message[];
+    getPendingMessages(myAddress: string): Message[];
+    updateMessageStatus(messageId: string, status: Message["status"], updates?: Partial<Message>): void;
+    /**
+     * 获取用户的所有消息
+     *
+     * @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 {
+    private userAddress;
+    constructor(userAddress: string);
+    private get db();
+    private getSessionId;
+    getSessionState(myAddress: string, peerAddress: string): SessionState | undefined;
+    updateSessionState(myAddress: string, peerAddress: string, updates: Partial<Omit<SessionState, "sessionId" | "myAddress" | "peerAddress">>): void;
+    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;
+}
+export declare const defaultPersistStorage: MessengerPersistStorage;
+export {};