wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,935 @@
+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 Database from "better-sqlite3";
+import * as path from "path";
+import * as fs from "fs";
+import { getWowDir } from "../local/util.js";
+function getWowDirDynamic() {
+  return getWowDir();
+}
+function getMessengerDbDir() {
+  return path.join(getWowDirDynamic(), "messenger");
+}
+function ensureDirExists(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function getUserDbPath(userAddress) {
+  const shortAddress = userAddress.toLowerCase().replace(/^0x/, "").slice(0, 16);
+  const messengerDbDir = getMessengerDbDir();
+  ensureDirExists(messengerDbDir);
+  return path.join(messengerDbDir, `${shortAddress}.db`);
+}
+function getGlobalDbPath() {
+  const messengerDbDir = getMessengerDbDir();
+  ensureDirExists(messengerDbDir);
+  return path.join(messengerDbDir, "global.db");
+}
+const userDbInstances = /* @__PURE__ */ new Map();
+let globalDbInstance = null;
+function getDatabase(userAddress) {
+  if (!userAddress) {
+    throw new Error("userAddress is required to get database");
+  }
+  const cached = userDbInstances.get(userAddress);
+  if (cached) {
+    return cached;
+  }
+  const dbPath = getUserDbPath(userAddress);
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("cache_size = -64000");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS signal_store (
+      store_type TEXT NOT NULL,
+      key TEXT NOT NULL,
+      value TEXT NOT NULL,
+      updated_at INTEGER DEFAULT (strftime('%s', 'now')),
+      PRIMARY KEY (store_type, key)
+    );
+    CREATE INDEX IF NOT EXISTS idx_signal_store_type ON signal_store(store_type);
+  `);
+  try {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        message_id TEXT PRIMARY KEY,
+        from_address TEXT NOT NULL,
+        to_address TEXT NOT NULL,
+        plaintext_hash TEXT NOT NULL,
+        plaintext TEXT,
+        guard_address TEXT,
+        passport_address TEXT,
+        direction TEXT NOT NULL,
+        status TEXT NOT NULL,
+        msg_type INTEGER NOT NULL,
+        leaf_index INTEGER,
+        prev_root TEXT,
+        new_root TEXT,
+        server_signature TEXT,
+        server_public_key TEXT,
+        server_timestamp INTEGER,
+        ark_recipient TEXT,
+        ark_recipient_pubkey TEXT,
+        ark_signature TEXT,
+        ark_timestamp INTEGER,
+        zip_metadata TEXT,
+        created_at INTEGER DEFAULT (strftime('%s', 'now') * 1000),
+        received_at INTEGER
+      );
+    `);
+  } catch (e) {
+  }
+  try {
+    db.exec("ALTER TABLE messages ADD COLUMN guard_address TEXT");
+  } catch (e) {
+  }
+  try {
+    db.exec("ALTER TABLE messages ADD COLUMN passport_address TEXT");
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "ALTER TABLE messages ADD COLUMN last_received_leaf_index INTEGER"
+    );
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_messages_from_to ON messages(from_address, to_address)"
+    );
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_messages_status ON messages(status)"
+    );
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_messages_leaf ON messages(leaf_index)"
+    );
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at)"
+    );
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_messages_server_ts ON messages(server_timestamp)"
+    );
+  } catch (e) {
+  }
+  try {
+    db.exec(
+      "CREATE INDEX IF NOT EXISTS idx_messages_received_at ON messages(received_at)"
+    );
+  } catch (e) {
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_states (
+      session_id TEXT PRIMARY KEY,
+      my_address TEXT NOT NULL,
+      peer_address TEXT NOT NULL,
+      current_root TEXT NOT NULL,
+      prev_root TEXT NOT NULL,
+      message_count INTEGER DEFAULT 0,
+      last_leaf_index INTEGER DEFAULT 0,
+      last_confirmed_hash TEXT,
+      last_sync_at INTEGER,
+      created_at INTEGER DEFAULT (strftime('%s', 'now')),
+      updated_at INTEGER DEFAULT (strftime('%s', 'now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_my_peer ON session_states(my_address, peer_address);
+  `);
+  userDbInstances.set(userAddress, db);
+  return db;
+}
+function getGlobalDatabase() {
+  if (globalDbInstance) {
+    return globalDbInstance;
+  }
+  const dbPath = getGlobalDbPath();
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma("cache_size = -10000");
+  db.pragma("busy_timeout = 5000");
+  globalDbInstance = db;
+  return db;
+}
+function resetDbConnection() {
+  for (const [_, db] of userDbInstances) {
+    try {
+      db.pragma("journal_mode = DELETE");
+    } catch (e) {
+    }
+  }
+  for (const [_, db] of userDbInstances) {
+    try {
+      db.close();
+    } catch (e) {
+    }
+  }
+  userDbInstances.clear();
+  if (globalDbInstance) {
+    try {
+      globalDbInstance.pragma("journal_mode = DELETE");
+    } catch (e) {
+    }
+    try {
+      globalDbInstance.close();
+    } catch (e) {
+    }
+    globalDbInstance = null;
+  }
+}
+process.on("exit", () => {
+  resetDbConnection();
+});
+process.on("SIGINT", () => {
+  resetDbConnection();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  resetDbConnection();
+  process.exit(0);
+});
+const STORE_TYPES = {
+  IDENTITY: "identity",
+  REGISTRATION_ID: "registration_id",
+  IDENTITIES: "identities",
+  PREKEYS: "prekeys",
+  SIGNED_PREKEYS: "signed_prekeys",
+  SESSIONS: "sessions",
+  META: "meta"
+};
+function arrayBufferToBase64(buffer) {
+  return Buffer.from(new Uint8Array(buffer)).toString("base64");
+}
+function base64ToArrayBuffer(base64) {
+  return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+function bufferEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  const va = new Uint8Array(a);
+  const vb = new Uint8Array(b);
+  for (let i = 0; i < va.length; i++) {
+    if (va[i] !== vb[i]) return false;
+  }
+  return true;
+}
+class SignalProtocolStorage {
+  constructor(userAddress, storeType = "default") {
+    __publicField(this, "storePrefix");
+    __publicField(this, "userAddress");
+    this.userAddress = userAddress;
+    this.storePrefix = storeType;
+  }
+  get db() {
+    return getDatabase(this.userAddress);
+  }
+  // Identity
+  async setIdentity(identity, registrationId) {
+    const persisted = {
+      pubKey: arrayBufferToBase64(identity.pubKey),
+      privKey: arrayBufferToBase64(identity.privKey)
+    };
+    this.putValue(STORE_TYPES.IDENTITY, JSON.stringify(persisted));
+    this.putValue(STORE_TYPES.REGISTRATION_ID, registrationId.toString());
+  }
+  async getIdentityKeyPair() {
+    const value = this.getValue(STORE_TYPES.IDENTITY);
+    if (!value) return void 0;
+    const persisted = JSON.parse(value);
+    return {
+      pubKey: base64ToArrayBuffer(persisted.pubKey),
+      privKey: base64ToArrayBuffer(persisted.privKey)
+    };
+  }
+  async getLocalRegistrationId() {
+    const value = this.getValue(STORE_TYPES.REGISTRATION_ID);
+    return value ? parseInt(value, 10) : void 0;
+  }
+  // Identity verification
+  async isTrustedIdentity(identifier, identityKey) {
+    const key = `${STORE_TYPES.IDENTITIES}:${identifier}`;
+    const existing = this.getValue(key);
+    if (!existing) return true;
+    return bufferEqual(base64ToArrayBuffer(existing), identityKey);
+  }
+  async saveIdentity(encodedAddress, publicKey) {
+    const key = `${STORE_TYPES.IDENTITIES}:${encodedAddress}`;
+    const existing = this.getValue(key);
+    const newValue = arrayBufferToBase64(publicKey);
+    this.putValue(key, newValue);
+    return existing ? bufferEqual(base64ToArrayBuffer(existing), publicKey) : true;
+  }
+  async loadIdentity(address) {
+    const key = `${STORE_TYPES.IDENTITIES}:${address}`;
+    const value = this.getValue(key);
+    return value ? base64ToArrayBuffer(value) : void 0;
+  }
+  // PreKeys
+  async loadPreKey(keyId) {
+    const key = `${STORE_TYPES.PREKEYS}:${keyId}`;
+    const value = this.getValue(key);
+    if (!value) return void 0;
+    const persisted = JSON.parse(value);
+    return {
+      pubKey: base64ToArrayBuffer(persisted.pubKey),
+      privKey: base64ToArrayBuffer(persisted.privKey)
+    };
+  }
+  async storePreKey(keyId, keyPair) {
+    const key = `${STORE_TYPES.PREKEYS}:${keyId}`;
+    const persisted = {
+      pubKey: arrayBufferToBase64(keyPair.pubKey),
+      privKey: arrayBufferToBase64(keyPair.privKey)
+    };
+    this.putValue(key, JSON.stringify(persisted));
+  }
+  async removePreKey(keyId) {
+    const key = `${STORE_TYPES.PREKEYS}:${keyId}`;
+    this.delValue(key);
+  }
+  // Signed PreKeys
+  async loadSignedPreKey(keyId) {
+    const key = `${STORE_TYPES.SIGNED_PREKEYS}:${keyId}`;
+    const value = this.getValue(key);
+    if (!value) return void 0;
+    const persisted = JSON.parse(value);
+    return {
+      pubKey: base64ToArrayBuffer(persisted.pubKey),
+      privKey: base64ToArrayBuffer(persisted.privKey)
+    };
+  }
+  async storeSignedPreKey(keyId, keyPair) {
+    const key = `${STORE_TYPES.SIGNED_PREKEYS}:${keyId}`;
+    const persisted = {
+      pubKey: arrayBufferToBase64(keyPair.pubKey),
+      privKey: arrayBufferToBase64(keyPair.privKey)
+    };
+    this.putValue(key, JSON.stringify(persisted));
+  }
+  async removeSignedPreKey(keyId) {
+    const key = `${STORE_TYPES.SIGNED_PREKEYS}:${keyId}`;
+    this.delValue(key);
+  }
+  // Sessions
+  async loadSession(encodedAddress) {
+    const key = `${STORE_TYPES.SESSIONS}:${encodedAddress}`;
+    return this.getValue(key);
+  }
+  async storeSession(encodedAddress, record) {
+    const key = `${STORE_TYPES.SESSIONS}:${encodedAddress}`;
+    this.putValue(key, record);
+  }
+  async removeSession(encodedAddress) {
+    const key = `${STORE_TYPES.SESSIONS}:${encodedAddress}`;
+    this.delValue(key);
+  }
+  // Meta
+  async getMeta() {
+    const value = this.getValue(STORE_TYPES.META);
+    if (!value) return { nextPreKeyId: 1 };
+    return JSON.parse(value);
+  }
+  async setMeta(meta) {
+    const current = await this.getMeta();
+    const updated = { ...current, ...meta };
+    this.putValue(STORE_TYPES.META, JSON.stringify(updated));
+  }
+  listPreKeys() {
+    const rows = this.db.prepare(
+      "SELECT key FROM signal_store WHERE store_type = ? AND key LIKE ?"
+    ).all(this.storePrefix, `${STORE_TYPES.PREKEYS}:%`);
+    return rows.map((r) => {
+      const id = r.key.replace(`${STORE_TYPES.PREKEYS}:`, "");
+      return Number(id);
+    });
+  }
+  // Private helpers
+  getValue(key) {
+    const row = this.db.prepare(
+      "SELECT value FROM signal_store WHERE store_type = ? AND key = ?"
+    ).get(this.storePrefix, key);
+    return row?.value;
+  }
+  putValue(key, value) {
+    this.db.prepare(
+      `
+      INSERT INTO signal_store (store_type, key, value, updated_at) 
+      VALUES (?, ?, ?, strftime('%s', 'now'))
+      ON CONFLICT(store_type, key) DO UPDATE SET 
+        value = excluded.value, 
+        updated_at = excluded.updated_at
+    `
+    ).run(this.storePrefix, key, value);
+  }
+  delValue(key) {
+    this.db.prepare(
+      "DELETE FROM signal_store WHERE store_type = ? AND key = ?"
+    ).run(this.storePrefix, key);
+  }
+}
+class MessageStorage {
+  constructor(userAddress) {
+    __publicField(this, "userAddress");
+    this.userAddress = userAddress;
+  }
+  get db() {
+    return getDatabase(this.userAddress);
+  }
+  saveMessage(message) {
+    const receivedAt = message.direction === "received" && !message.receivedAt ? Date.now() : message.receivedAt;
+    this.db.prepare(
+      `
+      INSERT INTO messages (
+        message_id, from_address, to_address, plaintext_hash,
+        plaintext, guard_address, passport_address, last_received_leaf_index, direction, status, msg_type,
+        leaf_index, prev_root, new_root, server_signature, server_public_key, server_timestamp,
+        ark_recipient, ark_recipient_pubkey, ark_signature, ark_timestamp, zip_metadata,
+        created_at, received_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(message_id) DO UPDATE SET
+        status = COALESCE(excluded.status, status),
+        leaf_index = COALESCE(excluded.leaf_index, leaf_index),
+        prev_root = COALESCE(excluded.prev_root, prev_root),
+        new_root = COALESCE(excluded.new_root, new_root),
+        server_signature = COALESCE(excluded.server_signature, server_signature),
+        server_public_key = COALESCE(excluded.server_public_key, server_public_key),
+        server_timestamp = COALESCE(excluded.server_timestamp, server_timestamp),
+        plaintext = COALESCE(excluded.plaintext, plaintext),
+        guard_address = COALESCE(excluded.guard_address, guard_address),
+        passport_address = COALESCE(excluded.passport_address, passport_address),
+        last_received_leaf_index = COALESCE(excluded.last_received_leaf_index, last_received_leaf_index),
+        ark_recipient = COALESCE(excluded.ark_recipient, ark_recipient),
+        ark_recipient_pubkey = COALESCE(excluded.ark_recipient_pubkey, ark_recipient_pubkey),
+        ark_signature = COALESCE(excluded.ark_signature, ark_signature),
+        ark_timestamp = COALESCE(excluded.ark_timestamp, ark_timestamp),
+        zip_metadata = COALESCE(excluded.zip_metadata, zip_metadata),
+        received_at = COALESCE(excluded.received_at, received_at)
+    `
+    ).run(
+      message.messageId,
+      message.fromAddress,
+      message.toAddress,
+      message.plaintextHash,
+      message.plaintext === void 0 ? null : message.plaintext,
+      message.guardAddress === void 0 ? null : message.guardAddress,
+      message.passportAddress === void 0 ? null : message.passportAddress,
+      message.lastReceivedLeafIndex === void 0 ? null : message.lastReceivedLeafIndex,
+      message.direction,
+      message.status,
+      message.msgType,
+      message.leafIndex === void 0 ? null : message.leafIndex,
+      message.prevRoot === void 0 ? null : message.prevRoot,
+      message.newRoot === void 0 ? null : message.newRoot,
+      message.serverSignature === void 0 ? null : message.serverSignature,
+      message.serverPublicKey === void 0 ? null : message.serverPublicKey,
+      message.serverTimestamp === void 0 ? null : message.serverTimestamp,
+      message.arkConfirmed?.recipient === void 0 ? null : message.arkConfirmed?.recipient,
+      message.arkConfirmed?.recipientPublicKey === void 0 ? null : message.arkConfirmed?.recipientPublicKey,
+      message.arkConfirmed?.signature === void 0 ? null : message.arkConfirmed?.signature,
+      message.arkConfirmed?.timestamp === void 0 ? null : message.arkConfirmed?.timestamp,
+      message.zipMetadata ? JSON.stringify(message.zipMetadata) : null,
+      message.createdAt,
+      receivedAt === void 0 ? null : receivedAt
+    );
+  }
+  getMessage(messageId) {
+    const row = this.db.prepare("SELECT * FROM messages WHERE message_id = ?").get(messageId);
+    if (!row) return void 0;
+    return this.rowToMessage(row);
+  }
+  getMessagesBySession(myAddress, peerAddress) {
+    const rows = this.db.prepare(
+      `
+        SELECT * FROM messages 
+        WHERE (from_address = ? AND to_address = ?) 
+           OR (from_address = ? AND to_address = ?)
+        ORDER BY created_at ASC
+      `
+    ).all(myAddress, peerAddress, peerAddress, myAddress);
+    return rows.map((r) => this.rowToMessage(r));
+  }
+  getPendingMessages(myAddress) {
+    const rows = this.db.prepare(
+      `
+        SELECT * FROM messages 
+        WHERE (from_address = ? OR to_address = ?) AND status = ?
+        ORDER BY created_at ASC
+      `
+    ).all(myAddress, myAddress, "pending");
+    return rows.map((r) => this.rowToMessage(r));
+  }
+  updateMessageStatus(messageId, status, updates) {
+    const fields = ["status = ?"];
+    const values = [status];
+    if (updates?.leafIndex !== void 0) {
+      fields.push("leaf_index = ?");
+      values.push(updates.leafIndex);
+    }
+    if (updates?.newRoot !== void 0) {
+      fields.push("new_root = ?");
+      values.push(updates.newRoot);
+    }
+    if (updates?.serverSignature !== void 0) {
+      fields.push("server_signature = ?");
+      values.push(updates.serverSignature);
+    }
+    if (updates?.serverTimestamp !== void 0) {
+      fields.push("server_timestamp = ?");
+      values.push(updates.serverTimestamp);
+    }
+    if (updates?.serverPublicKey !== void 0) {
+      fields.push("server_public_key = ?");
+      values.push(updates.serverPublicKey);
+    }
+    values.push(messageId);
+    this.db.prepare(
+      `
+      UPDATE messages SET ${fields.join(", ")} WHERE message_id = ?
+    `
+    ).run(...values);
+  }
+  /**
+   * 获取用户的所有消息
+   *
+   * @param userAddress 用户地址
+   * @returns 所有相关消息（发送和接收的）
+   */
+  getAllMessages(userAddress) {
+    const rows = this.db.prepare(
+      `
+        SELECT * FROM messages 
+        WHERE from_address = ? OR to_address = ?
+        ORDER BY created_at DESC
+      `
+    ).all(userAddress, userAddress);
+    return rows.map((r) => this.rowToMessage(r));
+  }
+  /**
+   * 通过消息 ID 获取消息
+   *
+   * @param messageId 消息 ID
+   * @returns 消息对象或 undefined
+   */
+  getMessageById(messageId) {
+    const row = this.db.prepare(
+      `
+        SELECT * FROM messages
+        WHERE message_id = ?
+      `
+    ).get(messageId);
+    if (!row) return void 0;
+    return this.rowToMessage(row);
+  }
+  /**
+   * 更新消息 ID（用于 Guard 消息确认后更新 messageId）
+   *
+   * 由于 message_id 是主键，需要通过删除旧记录并插入新记录来实现
+   *
+   * @param oldMessageId 旧消息 ID（internal_id）
+   * @param newMessageId 新消息 ID（正式的 message_id）
+   * @param updates 可选的更新字段
+   * @returns 是否成功更新
+   */
+  updateMessageId(oldMessageId, newMessageId, updates) {
+    const row = this.db.prepare("SELECT * FROM messages WHERE message_id = ?").get(oldMessageId);
+    if (!row) return false;
+    const getUpdatedValue = (updateValue, originalValue) => {
+      if (updateValue !== void 0) return updateValue;
+      return originalValue === null ? void 0 : originalValue;
+    };
+    const message = {
+      messageId: newMessageId,
+      fromAddress: row.from_address,
+      toAddress: row.to_address,
+      plaintextHash: row.plaintext_hash,
+      plaintext: row.plaintext === null ? void 0 : row.plaintext,
+      guardAddress: row.guard_address === null ? void 0 : row.guard_address,
+      passportAddress: row.passport_address === null ? void 0 : row.passport_address,
+      direction: row.direction,
+      status: updates?.status !== void 0 ? updates.status : row.status,
+      msgType: row.msg_type,
+      leafIndex: getUpdatedValue(updates?.leafIndex, row.leaf_index),
+      prevRoot: getUpdatedValue(updates?.prevRoot, row.prev_root),
+      newRoot: getUpdatedValue(updates?.newRoot, row.new_root),
+      serverSignature: getUpdatedValue(
+        updates?.serverSignature,
+        row.server_signature
+      ),
+      serverPublicKey: getUpdatedValue(
+        updates?.serverPublicKey,
+        row.server_public_key
+      ),
+      serverTimestamp: getUpdatedValue(
+        updates?.serverTimestamp,
+        row.server_timestamp
+      ),
+      arkConfirmed: row.ark_recipient ? {
+        recipient: row.ark_recipient,
+        recipientPublicKey: row.ark_recipient_pubkey,
+        signature: row.ark_signature,
+        timestamp: row.ark_timestamp
+      } : void 0,
+      zipMetadata: row.zip_metadata ? JSON.parse(row.zip_metadata) : void 0,
+      createdAt: row.created_at,
+      receivedAt: row.received_at === null ? void 0 : row.received_at
+    };
+    const transaction = this.db.transaction(() => {
+      this.db.prepare("DELETE FROM messages WHERE message_id = ?").run(oldMessageId);
+      this.saveMessage(message);
+    });
+    try {
+      transaction();
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  rowToMessage(row) {
+    if (row.to_address === null) {
+      throw new Error(`Message ${row.message_id} has null toAddress`);
+    }
+    return {
+      messageId: row.message_id,
+      fromAddress: row.from_address,
+      toAddress: row.to_address,
+      plaintextHash: row.plaintext_hash,
+      plaintext: row.plaintext === null ? void 0 : row.plaintext,
+      guardAddress: row.guard_address === null ? void 0 : row.guard_address,
+      passportAddress: row.passport_address === null ? void 0 : row.passport_address,
+      lastReceivedLeafIndex: row.last_received_leaf_index === null ? void 0 : row.last_received_leaf_index,
+      direction: row.direction,
+      status: row.status,
+      msgType: row.msg_type,
+      leafIndex: row.leaf_index === null ? void 0 : row.leaf_index,
+      prevRoot: row.prev_root === null ? void 0 : row.prev_root,
+      newRoot: row.new_root === null ? void 0 : row.new_root,
+      serverSignature: row.server_signature === null ? void 0 : row.server_signature,
+      serverPublicKey: row.server_public_key === null ? void 0 : row.server_public_key,
+      serverTimestamp: row.server_timestamp === null ? void 0 : row.server_timestamp,
+      arkConfirmed: row.ark_recipient ? {
+        recipient: row.ark_recipient,
+        recipientPublicKey: row.ark_recipient_pubkey,
+        signature: row.ark_signature,
+        timestamp: row.ark_timestamp
+      } : void 0,
+      zipMetadata: row.zip_metadata ? JSON.parse(row.zip_metadata) : void 0,
+      createdAt: row.created_at,
+      receivedAt: row.received_at === null ? void 0 : row.received_at
+    };
+  }
+  /**
+   * 获取最后收到的消息序号（用于消息同步确认）
+   *
+   * 查询指定会话中，用户作为接收者时，发送者最后收到的消息序号
+   * 用于在发送新消息时，告诉对方我已经收到了哪些消息
+   *
+   * @param myAddress 当前用户地址
+   * @param peerAddress 对方地址
+   * @returns 最后收到的消息序号（leafIndex），如果没有则返回 -1
+   */
+  getLastReceivedLeafIndex(myAddress, peerAddress) {
+    const row = this.db.prepare(
+      `
+				SELECT MAX(last_received_leaf_index) as max_index
+				FROM messages
+				WHERE from_address = ? AND to_address = ?
+					AND last_received_leaf_index IS NOT NULL
+			`
+    ).get(peerAddress, myAddress);
+    return row?.max_index ?? -1;
+  }
+}
+class SessionStateStorage {
+  constructor(userAddress) {
+    __publicField(this, "userAddress");
+    this.userAddress = userAddress;
+  }
+  get db() {
+    return getDatabase(this.userAddress);
+  }
+  getSessionId(myAddress, peerAddress) {
+    const addresses = [myAddress, peerAddress].sort();
+    return `${addresses[0]}:${addresses[1]}`;
+  }
+  getSessionState(myAddress, peerAddress) {
+    const sessionId = this.getSessionId(myAddress, peerAddress);
+    const row = this.db.prepare("SELECT * FROM session_states WHERE session_id = ?").get(sessionId);
+    if (!row) return void 0;
+    return {
+      sessionId: row.session_id,
+      myAddress: row.my_address,
+      peerAddress: row.peer_address,
+      currentRoot: row.current_root,
+      prevRoot: row.prev_root,
+      messageCount: row.message_count,
+      lastLeafIndex: row.last_leaf_index,
+      lastConfirmedHash: row.last_confirmed_hash === null ? "" : row.last_confirmed_hash,
+      lastSyncAt: row.last_sync_at === null ? 0 : row.last_sync_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  updateSessionState(myAddress, peerAddress, updates) {
+    const sessionId = this.getSessionId(myAddress, peerAddress);
+    const existing = this.getSessionState(myAddress, peerAddress);
+    const now = Date.now();
+    if (existing) {
+      const updated = { ...existing, ...updates, updatedAt: now };
+      this.db.prepare(
+        `
+        UPDATE session_states SET
+          current_root = ?,
+          prev_root = ?,
+          message_count = ?,
+          last_leaf_index = ?,
+          last_confirmed_hash = ?,
+          last_sync_at = ?,
+          updated_at = ?
+        WHERE session_id = ?
+      `
+      ).run(
+        updated.currentRoot,
+        updated.prevRoot,
+        updated.messageCount,
+        updated.lastLeafIndex,
+        updated.lastConfirmedHash,
+        updated.lastSyncAt,
+        updated.updatedAt,
+        sessionId
+      );
+    } else {
+      const initialRoot = "0".repeat(64);
+      this.db.prepare(
+        `
+        INSERT INTO session_states (
+          session_id, my_address, peer_address, current_root, prev_root,
+          message_count, last_leaf_index, last_confirmed_hash, last_sync_at,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `
+      ).run(
+        sessionId,
+        myAddress,
+        peerAddress,
+        updates.currentRoot ?? initialRoot,
+        updates.prevRoot ?? initialRoot,
+        updates.messageCount ?? 0,
+        updates.lastLeafIndex ?? 0,
+        updates.lastConfirmedHash ?? "",
+        updates.lastSyncAt ?? 0,
+        now,
+        now
+      );
+    }
+  }
+  getCurrentRoot(myAddress, peerAddress) {
+    const state = this.getSessionState(myAddress, peerAddress);
+    return state?.currentRoot ?? "0".repeat(64);
+  }
+}
+class MessengerPersistStorage {
+  constructor() {
+    __publicField(this, "initialized", false);
+  }
+  get db() {
+    const db = getGlobalDatabase();
+    if (!this.initialized) {
+      this.initTable(db);
+      this.initialized = true;
+    }
+    return db;
+  }
+  /**
+   * 初始化存储表
+   */
+  initTable(db) {
+    db.exec(`
+			CREATE TABLE IF NOT EXISTS messenger_manager_state (
+				instance_id TEXT PRIMARY KEY,
+				state_data TEXT NOT NULL,
+				updated_at INTEGER NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_messenger_state_updated ON messenger_manager_state(updated_at);
+		`);
+    db.exec(`
+			CREATE TABLE IF NOT EXISTS sse_connection_locks (
+				account_address TEXT PRIMARY KEY,
+				process_id TEXT NOT NULL,
+				instance_id TEXT NOT NULL,
+				last_heartbeat INTEGER NOT NULL,
+				created_at INTEGER NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_sse_lock_heartbeat ON sse_connection_locks(last_heartbeat);
+		`);
+  }
+  /**
+   * 保存 Messenger 配置和账号信息
+   *
+   * @param instanceId 实例标识（用于区分不同的 MessengerManager 实例）
+   * @param state 要保存的状态
+   */
+  saveState(instanceId, state) {
+    const data = JSON.stringify(state);
+    const now = Date.now();
+    this.db.prepare(
+      `
+				INSERT INTO messenger_manager_state (instance_id, state_data, updated_at)
+				VALUES (?, ?, ?)
+				ON CONFLICT(instance_id) DO UPDATE SET
+					state_data = excluded.state_data,
+					updated_at = excluded.updated_at
+			`
+    ).run(instanceId, data, now);
+  }
+  /**
+   * 加载 Messenger 配置和账号信息
+   *
+   * @param instanceId 实例标识
+   * @returns 保存的状态，如果不存在返回 null
+   */
+  loadState(instanceId) {
+    const row = this.db.prepare(
+      "SELECT state_data FROM messenger_manager_state WHERE instance_id = ?"
+    ).get(instanceId);
+    if (!row?.state_data) return null;
+    try {
+      return JSON.parse(row.state_data);
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * 删除保存的状态
+   *
+   * @param instanceId 实例标识
+   */
+  deleteState(instanceId) {
+    this.db.prepare(
+      "DELETE FROM messenger_manager_state WHERE instance_id = ?"
+    ).run(instanceId);
+  }
+  /**
+   * 获取所有实例ID列表
+   */
+  getAllInstanceIds() {
+    const rows = this.db.prepare(
+      "SELECT instance_id FROM messenger_manager_state ORDER BY updated_at DESC"
+    ).all();
+    return rows.map((r) => r.instance_id);
+  }
+  get processId() {
+    return `pid_${process.pid}_${Date.now()}`;
+  }
+  /**
+   * 尝试获取指定账号的 SSE 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   * @returns 是否成功获取锁
+   */
+  tryAcquireSSELock(accountAddress, instanceId) {
+    const now = Date.now();
+    const heartbeatTimeout = 15e3;
+    const transaction = this.db.transaction(() => {
+      const row = this.db.prepare(
+        "SELECT * FROM sse_connection_locks WHERE account_address = ?"
+      ).get(accountAddress.toLowerCase());
+      if (row) {
+        if (row.instance_id === instanceId) {
+          this.db.prepare(
+            "UPDATE sse_connection_locks SET last_heartbeat = ? WHERE account_address = ?"
+          ).run(now, accountAddress.toLowerCase());
+          return true;
+        }
+        if (now - row.last_heartbeat < heartbeatTimeout) {
+          return false;
+        }
+      }
+      this.db.prepare(
+        `
+					INSERT INTO sse_connection_locks (
+						account_address, process_id, instance_id, last_heartbeat, created_at
+					) VALUES (?, ?, ?, ?, ?)
+					ON CONFLICT(account_address) DO UPDATE SET
+						process_id = excluded.process_id,
+						instance_id = excluded.instance_id,
+						last_heartbeat = excluded.last_heartbeat
+				`
+      ).run(
+        accountAddress.toLowerCase(),
+        this.processId,
+        instanceId,
+        now,
+        now
+      );
+      return true;
+    });
+    try {
+      return transaction();
+    } catch (error) {
+      console.warn("Failed to acquire SSE lock:", error);
+      return false;
+    }
+  }
+  /**
+   * 更新 SSE 连接锁的心跳
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   */
+  updateSSELockHeartbeat(accountAddress, instanceId) {
+    const now = Date.now();
+    try {
+      this.db.prepare(
+        "UPDATE sse_connection_locks SET last_heartbeat = ? WHERE account_address = ? AND instance_id = ?"
+      ).run(now, accountAddress.toLowerCase(), instanceId);
+    } catch (error) {
+      console.warn("Failed to update SSE lock heartbeat:", error);
+    }
+  }
+  /**
+   * 释放指定账号的 SSE 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   */
+  releaseSSELock(accountAddress, instanceId) {
+    try {
+      this.db.prepare(
+        "DELETE FROM sse_connection_locks WHERE account_address = ? AND instance_id = ?"
+      ).run(accountAddress.toLowerCase(), instanceId);
+    } catch (error) {
+      console.warn("Failed to release SSE lock:", error);
+    }
+  }
+  /**
+   * 检查是否持有指定账号的 SSE 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   * @returns 是否持有锁
+   */
+  holdsSSELock(accountAddress, instanceId) {
+    const row = this.db.prepare(
+      "SELECT * FROM sse_connection_locks WHERE account_address = ? AND instance_id = ?"
+    ).get(accountAddress.toLowerCase(), instanceId);
+    return !!row;
+  }
+}
+const defaultPersistStorage = new MessengerPersistStorage();
+export {
+  MessageStorage,
+  MessengerPersistStorage,
+  SessionStateStorage,
+  SignalProtocolStorage,
+  defaultPersistStorage,
+  resetDbConnection
+};