wowok 2.1.10 → 2.1.13

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

@@ -1,1118 +1,1010 @@
-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);
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Messenger 管理器
+ *
+ * 支持最多20个账号同时收发消息
+ * 自动从account模块筛选有m字段的账号
+ * 自动初始化、注册并接收消息
+ */
 import { Messenger } from "./messenger.js";
 import { MessageStorage } from "./storage.js";
 import { MessengerPersistStorage } from "./storage.js";
 import { MessageType, MessageStatus, WTS_MAX_MESSAGE_COUNT } from "./types.js";
-import {
-  MessengerError,
-  MessengerErrorCode,
-  DEFAULT_MESSENGER_CONFIG
-} from "./types.js";
+import { MessengerError, MessengerErrorCode, DEFAULT_MESSENGER_CONFIG, } from "./types.js";
 import { canonicalizeJson } from "./utils.js";
 import { MAX_MESSENGER_ACCOUNTS } from "../local/account.js";
 import { GetAccountOrMark_Address } from "../local/index.js";
 const MAX_ACCOUNTS = MAX_MESSENGER_ACCOUNTS;
-class MessengerManager {
-  constructor(options) {
-    __publicField(this, "accounts", /* @__PURE__ */ new Map());
-    __publicField(this, "config");
-    __publicField(this, "messageListeners", /* @__PURE__ */ new Set());
-    __publicField(this, "pollingTimers", /* @__PURE__ */ new Map());
-    __publicField(this, "isWatching", false);
-    __publicField(this, "persistStorage");
-    __publicField(this, "instanceId");
-    __publicField(this, "accountRefreshTimer", null);
-    __publicField(this, "sseHeartbeatTimer", null);
-    __publicField(this, "sseLockedAccounts", /* @__PURE__ */ new Set());
-    this.config = {
-      ...DEFAULT_MESSENGER_CONFIG,
-      ...options?.messengerConfig
-    };
-    this.instanceId = options?.instanceId || "default";
-    this.persistStorage = new MessengerPersistStorage();
-  }
-  findAccount(address) {
-    return this.accounts.get(address.toLowerCase());
-  }
-  getConfig() {
-    return this.config;
-  }
-  get_accounts() {
-    return Array.from(this.accounts.values()).map((acc) => acc.address);
-  }
-  async refresh_accounts() {
-    const { Account } = await import("../local/account.js");
-    const messengerAccounts = await Account.Instance().list_messenger_accounts();
-    const currentAddresses = new Set(this.accounts.keys());
-    const newAddresses = new Set(
-      messengerAccounts.map((a) => a.address.toLowerCase())
-    );
-    for (const address of currentAddresses) {
-      if (!newAddresses.has(address)) {
-        this.remove_account_internal(address);
-      }
-    }
-    for (const account of messengerAccounts) {
-      const addressLower = account.address.toLowerCase();
-      if (!this.accounts.has(addressLower)) {
-        await this.add_account_internal(account.address);
-      }
-    }
-    if (this.accounts.size > 0 && !this.isWatching) {
-      this.startPolling();
-    } else if (this.accounts.size === 0 && this.isWatching) {
-      this.stopPolling();
-    }
-    await this.syncAllContactLists();
-  }
-  async start() {
-    await this.refresh_accounts();
-    let hasSSEFailure = false;
-    for (const account of this.accounts.values()) {
-      if (!account.messenger.isEventSourceConnected()) {
-        try {
-          const hasLock = this.persistStorage.tryAcquireSSELock(
-            account.address,
-            this.instanceId
-          );
-          if (hasLock) {
-            this.sseLockedAccounts.add(
-              account.address.toLowerCase()
-            );
-            await account.messenger.connectEventSource(
-              (messages) => {
-                for (const listener of this.messageListeners) {
-                  listener(messages);
-                }
-              }
-            );
-          } else {
-            console.debug(
-              `Another process holds SSE lock for ${account.address}, using polling`
-            );
-            hasSSEFailure = true;
-          }
-        } catch (err) {
-          console.warn(
-            `Failed to connect SSE for ${account.address}, falling back to polling:`,
-            err
-          );
-          hasSSEFailure = true;
-          this.persistStorage.releaseSSELock(
-            account.address,
-            this.instanceId
-          );
-          this.sseLockedAccounts.delete(
-            account.address.toLowerCase()
-          );
-        }
-      }
-    }
-    if (hasSSEFailure && !this.isWatching) {
-      this.startPolling();
-    }
-    this.startSSEHeartbeat();
-    if (this.accountRefreshTimer) {
-      clearInterval(this.accountRefreshTimer);
-    }
-    this.accountRefreshTimer = setInterval(() => {
-      this.refresh_accounts().catch((err) => {
-        console.error("Failed to refresh accounts:", err);
-      });
-    }, this.config.watch_interval_ms);
-  }
-  stop() {
-    if (this.accountRefreshTimer) {
-      clearInterval(this.accountRefreshTimer);
-      this.accountRefreshTimer = null;
-    }
-    this.stopSSEHeartbeat();
-    for (const accountAddress of this.sseLockedAccounts) {
-      this.persistStorage.releaseSSELock(accountAddress, this.instanceId);
-    }
-    this.sseLockedAccounts.clear();
-    this.stopPolling();
-    this.clear_accounts();
-  }
-  startSSEHeartbeat() {
-    if (this.sseHeartbeatTimer) {
-      clearInterval(this.sseHeartbeatTimer);
-    }
-    this.sseHeartbeatTimer = setInterval(() => {
-      for (const accountAddress of this.sseLockedAccounts) {
-        this.persistStorage.updateSSELockHeartbeat(
-          accountAddress,
-          this.instanceId
-        );
-      }
-    }, 5e3);
-  }
-  stopSSEHeartbeat() {
-    if (this.sseHeartbeatTimer) {
-      clearInterval(this.sseHeartbeatTimer);
-      this.sseHeartbeatTimer = null;
-    }
-  }
-  async add_account_internal(address) {
-    const addressLower = address.toLowerCase();
-    if (this.accounts.size >= MAX_ACCOUNTS) {
-      throw new MessengerError(
-        MessengerErrorCode.INVALID_INPUT,
-        `Maximum ${MAX_ACCOUNTS} accounts allowed`
-      );
-    }
-    const messenger = new Messenger(addressLower, this.config);
-    try {
-      await messenger.initialize();
-    } catch (error) {
-      throw new MessengerError(
-        MessengerErrorCode.SERVER_ERROR,
-        `Failed to initialize account ${addressLower}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    const contactLists = {
-      friends: [],
-      guards: [],
-      lastUpdatedAt: 0
-    };
-    this.accounts.set(addressLower, {
-      address: addressLower,
-      messenger,
-      initialized: true,
-      contactLists
-    });
-    if (this.isWatching) {
-      this.startAccountPolling(addressLower);
-    }
-  }
-  remove_account_internal(address) {
-    const addressLower = address.toLowerCase();
-    const account = this.accounts.get(addressLower);
-    if (!account) return false;
-    if (account.initialized && account.messenger) {
-      account.messenger.disconnectEventSource();
-      account.messenger.disconnect();
-    }
-    const timer = this.pollingTimers.get(account.address);
-    if (timer) {
-      clearInterval(timer);
-      this.pollingTimers.delete(account.address);
-    }
-    this.persistStorage.releaseSSELock(addressLower, this.instanceId);
-    this.sseLockedAccounts.delete(addressLower);
-    return this.accounts.delete(addressLower);
-  }
-  clear_accounts() {
-    this.stopPolling();
-    for (const info of this.accounts.values()) {
-      info.messenger.disconnectEventSource();
-      info.messenger.disconnect();
-    }
-    this.accounts.clear();
-  }
-  async send(from, to, content, options) {
-    const { Account } = await import("../local/account.js");
-    let accountInfo = this.findAccount(from);
-    if (!accountInfo) {
-      const account = await Account.Instance().get(from, false);
-      if (!account) {
-        throw new MessengerError(
-          MessengerErrorCode.IDENTITY_NOT_FOUND,
-          `Account ${from} not found`
-        );
-      }
-      if (account.m == null) {
-        if (options?.new_messenger_name == null) {
-          throw new MessengerError(
-            MessengerErrorCode.ACCOUNT_MESSENGER_NOT_ENABLED,
-            `Account messenger name not set. Use new_messenger_name parameter to set it automatically.`
-          );
-        }
-        await Account.Instance().set_messenger(
-          from,
-          options.new_messenger_name
-        );
-      }
-      await this.refresh_accounts();
-      accountInfo = this.findAccount(from);
-      if (!accountInfo) {
-        throw new MessengerError(
-          MessengerErrorCode.SERVER_ERROR,
-          `Failed to add account ${from} to messenger manager`
-        );
-      }
-    }
-    if (options?.new_messenger_name != null) {
-      const account = await Account.Instance().get(from, false);
-      if (account && account.m !== options.new_messenger_name) {
-        await Account.Instance().set_messenger(
-          from,
-          options.new_messenger_name
-        );
-      }
-    }
-    return accountInfo.messenger.sendMessage(to, content, {
-      guardAddress: options?.guardAddress,
-      passportAddress: options?.passportAddress,
-      force: options?.force
-    });
-  }
-  async send_file(from, to, filePath, options) {
-    const { Account } = await import("../local/account.js");
-    let accountInfo = this.findAccount(from);
-    if (!accountInfo) {
-      const account = await Account.Instance().get(from, false);
-      if (!account) {
-        throw new MessengerError(
-          MessengerErrorCode.IDENTITY_NOT_FOUND,
-          `Account ${from} not found`
-        );
-      }
-      if (account.m == null) {
-        if (options?.new_messenger_name == null) {
-          throw new MessengerError(
-            MessengerErrorCode.ACCOUNT_MESSENGER_NOT_ENABLED,
-            `Account messenger name not set. Use new_messenger_name parameter to set it automatically.`
-          );
-        }
-        await Account.Instance().set_messenger(
-          from,
-          options.new_messenger_name
-        );
-      }
-      await this.refresh_accounts();
-      accountInfo = this.findAccount(from);
-      if (!accountInfo) {
-        throw new MessengerError(
-          MessengerErrorCode.SERVER_ERROR,
-          `Failed to add account ${from} to messenger manager`
-        );
-      }
-    }
-    if (options?.new_messenger_name != null) {
-      const account = await Account.Instance().get(from, false);
-      if (account && account.m !== options.new_messenger_name) {
-        await Account.Instance().set_messenger(
-          from,
-          options.new_messenger_name
-        );
-      }
-    }
-    return accountInfo.messenger.sendZipFile(to, filePath, {
-      fileName: options?.fileName,
-      contentType: options?.contentType,
-      guardAddress: options?.guardAddress,
-      passportAddress: options?.passportAddress,
-      force: options?.force
-    });
-  }
-  async watch(filter) {
-    let messages = [];
-    if (filter?.account) {
-      const address = filter.account.toLowerCase();
-      const messageStorage = new MessageStorage(address);
-      messages = messageStorage.getAllMessages(address);
-    } else {
-      for (const account of this.accounts.values()) {
-        const messageStorage = new MessageStorage(account.address);
-        const accountMessages = messageStorage.getAllMessages(
-          account.address
-        );
-        messages.push(...accountMessages);
-      }
-    }
-    if (filter) {
-      const peerAddress = filter.peerAddress ? await GetAccountOrMark_Address(filter.peerAddress) : void 0;
-      messages = messages.filter((msg) => {
-        if (filter.account) {
-          const accountLower = filter.account.toLowerCase();
-          const fromLower = msg.fromAddress.toLowerCase();
-          const toLower = msg.toAddress.toLowerCase();
-          if (fromLower !== accountLower && toLower !== accountLower) {
-            return false;
-          }
-        }
-        if (filter.direction && msg.direction !== filter.direction) {
-          return false;
-        }
-        if (filter.status && msg.status !== filter.status) {
-          return false;
-        }
-        if (filter.msgType !== void 0 && msg.msgType !== filter.msgType) {
-          return false;
-        }
-        if (filter.contentType) {
-          switch (filter.contentType) {
-            case "text":
-              if (msg.msgType !== MessageType.NORMAL_MESSAGE)
-                return false;
-              break;
-            case "zip":
-              if (!msg.zipMetadata) return false;
-              break;
-            case "wts":
-              if (!msg.zipMetadata || msg.zipMetadata?.contentType !== "wts") {
-                return false;
-              }
-              break;
-            case "wip":
-              if (!msg.zipMetadata || msg.zipMetadata?.contentType !== "wip") {
-                return false;
-              }
-              break;
-          }
-        }
-        if (filter.peerAddress && peerAddress) {
-          const peer = peerAddress.toLowerCase();
-          const from = msg.fromAddress.toLowerCase();
-          const to = msg.toAddress.toLowerCase();
-          if (from !== peer && to !== peer) {
-            return false;
-          }
-        }
-        const timeField = filter.timeField || "createdAt";
-        if (filter.startTime !== void 0 || filter.endTime !== void 0) {
-          const msgTime = msg[timeField];
-          if (msgTime !== void 0) {
-            if (filter.startTime !== void 0 && msgTime < filter.startTime) {
-              return false;
-            }
-            if (filter.endTime !== void 0 && msgTime > filter.endTime) {
-              return false;
+export class MessengerManager {
+    accounts = new Map();
+    config;
+    messageListeners = new Set();
+    pollingTimers = new Map();
+    isWatching = false;
+    persistStorage;
+    instanceId;
+    accountRefreshTimer = null;
+    sseHeartbeatTimer = null;
+    sseLockedAccounts = new Set();
+    constructor(options) {
+        this.config = {
+            ...DEFAULT_MESSENGER_CONFIG,
+            ...options?.messengerConfig,
+        };
+        this.instanceId = options?.instanceId || "default";
+        this.persistStorage = new MessengerPersistStorage();
+    }
+    findAccount(address) {
+        return this.accounts.get(address.toLowerCase());
+    }
+    getConfig() {
+        return this.config;
+    }
+    get_accounts() {
+        return Array.from(this.accounts.values()).map((acc) => acc.address);
+    }
+    async refresh_accounts() {
+        const { Account } = await import("../local/account.js");
+        const messengerAccounts = await Account.Instance().list_messenger_accounts();
+        const currentAddresses = new Set(this.accounts.keys());
+        const newAddresses = new Set(messengerAccounts.map((a) => a.address.toLowerCase()));
+        for (const address of currentAddresses) {
+            if (!newAddresses.has(address)) {
+                this.remove_account_internal(address);
             }
-          }
         }
-        if (filter.createdAtStart !== void 0 && msg.createdAt < filter.createdAtStart) {
-          return false;
-        }
-        if (filter.createdAtEnd !== void 0 && msg.createdAt > filter.createdAtEnd) {
-          return false;
+        for (const account of messengerAccounts) {
+            const addressLower = account.address.toLowerCase();
+            if (!this.accounts.has(addressLower)) {
+                await this.add_account_internal(account.address);
+            }
         }
-        if (filter.receivedAtStart !== void 0) {
-          if (msg.receivedAt === void 0 || msg.receivedAt < filter.receivedAtStart) {
-            return false;
-          }
+        if (this.accounts.size > 0 && !this.isWatching) {
+            this.startPolling();
+        }
+        else if (this.accounts.size === 0 && this.isWatching) {
+            this.stopPolling();
+        }
+        await this.syncAllContactLists();
+    }
+    async start() {
+        await this.refresh_accounts();
+        let hasSSEFailure = false;
+        for (const account of this.accounts.values()) {
+            if (!account.messenger.isEventSourceConnected()) {
+                try {
+                    const hasLock = this.persistStorage.tryAcquireSSELock(account.address, this.instanceId);
+                    if (hasLock) {
+                        this.sseLockedAccounts.add(account.address.toLowerCase());
+                        await account.messenger.connectEventSource((messages) => {
+                            for (const listener of this.messageListeners) {
+                                listener(messages);
+                            }
+                        });
+                    }
+                    else {
+                        console.debug(`Another process holds SSE lock for ${account.address}, using polling`);
+                        hasSSEFailure = true;
+                    }
+                }
+                catch (err) {
+                    console.warn(`Failed to connect SSE for ${account.address}, falling back to polling:`, err);
+                    hasSSEFailure = true;
+                    this.persistStorage.releaseSSELock(account.address, this.instanceId);
+                    this.sseLockedAccounts.delete(account.address.toLowerCase());
+                }
+            }
         }
-        if (filter.receivedAtEnd !== void 0) {
-          if (msg.receivedAt === void 0 || msg.receivedAt > filter.receivedAtEnd) {
-            return false;
-          }
+        if (hasSSEFailure && !this.isWatching) {
+            this.startPolling();
         }
-        if (filter.serverTimestampStart !== void 0) {
-          if (msg.serverTimestamp === void 0 || msg.serverTimestamp < filter.serverTimestampStart) {
-            return false;
-          }
+        this.startSSEHeartbeat();
+        if (this.accountRefreshTimer) {
+            clearInterval(this.accountRefreshTimer);
         }
-        if (filter.serverTimestampEnd !== void 0) {
-          if (msg.serverTimestamp === void 0 || msg.serverTimestamp > filter.serverTimestampEnd) {
-            return false;
-          }
+        this.accountRefreshTimer = setInterval(() => {
+            this.refresh_accounts().catch((err) => {
+                console.error("Failed to refresh accounts:", err);
+            });
+        }, this.config.watch_interval_ms);
+    }
+    stop() {
+        if (this.accountRefreshTimer) {
+            clearInterval(this.accountRefreshTimer);
+            this.accountRefreshTimer = null;
         }
-        if (filter.decryptedOnly && !msg.plaintext) {
-          return false;
+        this.stopSSEHeartbeat();
+        for (const accountAddress of this.sseLockedAccounts) {
+            this.persistStorage.releaseSSELock(accountAddress, this.instanceId);
         }
-        if (filter.arkConfirmedOnly) {
-          if (!msg.arkConfirmed) {
-            return false;
-          }
+        this.sseLockedAccounts.clear();
+        this.stopPolling();
+        this.clear_accounts();
+    }
+    startSSEHeartbeat() {
+        if (this.sseHeartbeatTimer) {
+            clearInterval(this.sseHeartbeatTimer);
         }
-        if (filter.proofedOnly) {
-          if (!msg.proof) {
-            return false;
-          }
+        this.sseHeartbeatTimer = setInterval(() => {
+            for (const accountAddress of this.sseLockedAccounts) {
+                this.persistStorage.updateSSELockHeartbeat(accountAddress, this.instanceId);
+            }
+        }, 5000);
+    }
+    stopSSEHeartbeat() {
+        if (this.sseHeartbeatTimer) {
+            clearInterval(this.sseHeartbeatTimer);
+            this.sseHeartbeatTimer = null;
         }
-        if (filter.arkTimestampStart !== void 0) {
-          if (msg.arkConfirmed === void 0 || msg.arkConfirmed.timestamp < filter.arkTimestampStart) {
-            return false;
-          }
+    }
+    async add_account_internal(address) {
+        const addressLower = address.toLowerCase();
+        if (this.accounts.size >= MAX_ACCOUNTS) {
+            throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Maximum ${MAX_ACCOUNTS} accounts allowed`);
         }
-        if (filter.arkTimestampEnd !== void 0) {
-          if (msg.arkConfirmed === void 0 || msg.arkConfirmed.timestamp > filter.arkTimestampEnd) {
-            return false;
-          }
+        const messenger = new Messenger(addressLower, this.config);
+        try {
+            await messenger.initialize();
         }
-        if (filter.hasLastReceivedIndexOnly) {
-          if (msg.lastReceivedLeafIndex === void 0 || msg.lastReceivedLeafIndex === null) {
-            return false;
-          }
+        catch (error) {
+            throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Failed to initialize account ${addressLower}: ${error instanceof Error ? error.message : String(error)}`);
         }
-        if (filter.lastReceivedIndexMin !== void 0) {
-          if (msg.lastReceivedLeafIndex === void 0 || msg.lastReceivedLeafIndex < filter.lastReceivedIndexMin) {
-            return false;
-          }
+        const contactLists = {
+            friends: [],
+            guards: [],
+            lastUpdatedAt: 0,
+        };
+        this.accounts.set(addressLower, {
+            address: addressLower,
+            messenger,
+            initialized: true,
+            contactLists,
+        });
+        if (this.isWatching) {
+            this.startAccountPolling(addressLower);
         }
-        if (filter.lastReceivedIndexMax !== void 0) {
-          if (msg.lastReceivedLeafIndex === void 0 || msg.lastReceivedLeafIndex > filter.lastReceivedIndexMax) {
+    }
+    remove_account_internal(address) {
+        const addressLower = address.toLowerCase();
+        const account = this.accounts.get(addressLower);
+        if (!account)
             return false;
-          }
+        if (account.initialized && account.messenger) {
+            account.messenger.disconnectEventSource();
+            account.messenger.disconnect();
+        }
+        const timer = this.pollingTimers.get(account.address);
+        if (timer) {
+            clearInterval(timer);
+            this.pollingTimers.delete(account.address);
+        }
+        this.persistStorage.releaseSSELock(addressLower, this.instanceId);
+        this.sseLockedAccounts.delete(addressLower);
+        return this.accounts.delete(addressLower);
+    }
+    clear_accounts() {
+        this.stopPolling();
+        for (const info of this.accounts.values()) {
+            info.messenger.disconnectEventSource();
+            info.messenger.disconnect();
+        }
+        this.accounts.clear();
+    }
+    async send(from, to, content, options) {
+        const { Account } = await import("../local/account.js");
+        let accountInfo = this.findAccount(from);
+        if (!accountInfo) {
+            const account = await Account.Instance().get(from, false);
+            if (!account) {
+                throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, `Account ${from} not found`);
+            }
+            if (account.m == null) {
+                if (options?.new_messenger_name == null) {
+                    throw new MessengerError(MessengerErrorCode.ACCOUNT_MESSENGER_NOT_ENABLED, `Account messenger name not set. Use new_messenger_name parameter to set it automatically.`);
+                }
+                await Account.Instance().set_messenger(from, options.new_messenger_name);
+            }
+            await this.refresh_accounts();
+            accountInfo = this.findAccount(from);
+            if (!accountInfo) {
+                throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Failed to add account ${from} to messenger manager`);
+            }
         }
-        if (filter.keyword && msg.plaintext) {
-          if (!msg.plaintext.toLowerCase().includes(filter.keyword.toLowerCase())) {
-            return false;
-          }
+        if (options?.new_messenger_name != null) {
+            const account = await Account.Instance().get(from, false);
+            if (account && account.m !== options.new_messenger_name) {
+                await Account.Instance().set_messenger(from, options.new_messenger_name);
+            }
         }
-        if (filter.listFilterMode && filter.listFilterMode !== "any") {
-          const msgAccount = this.findAccount(msg.toAddress);
-          if (!msgAccount) return false;
-          const senderAddress = msg.fromAddress.toLowerCase();
-          const lists = msgAccount.contactLists;
-          const friends = new Set(
-            lists.friends.map((a) => a.toLowerCase())
-          );
-          const guards = new Set(
-            lists.guards.map((g) => g.guardAddress.toLowerCase())
-          );
-          const inFriends = friends.has(senderAddress);
-          const inGuards = guards.has(senderAddress);
-          const isStranger = !inFriends && !inGuards;
-          switch (filter.listFilterMode) {
-            case "friends":
-              if (!inFriends) return false;
-              break;
-            case "guard":
-              if (!inGuards) return false;
-              break;
-            case "stranger":
-              if (!isStranger) return false;
-              break;
-          }
-          if (filter.customListFilter) {
-            const {
-              includeAddresses,
-              excludeAddresses,
-              relation = "union"
-            } = filter.customListFilter;
-            if (excludeAddresses) {
-              const excludeSet = new Set(
-                excludeAddresses.map((a) => a.toLowerCase())
-              );
-              if (excludeSet.has(senderAddress)) return false;
+        return accountInfo.messenger.sendMessage(to, content, {
+            guardAddress: options?.guardAddress,
+            passportAddress: options?.passportAddress,
+            force: options?.force,
+        });
+    }
+    async send_file(from, to, filePath, options) {
+        const { Account } = await import("../local/account.js");
+        let accountInfo = this.findAccount(from);
+        if (!accountInfo) {
+            const account = await Account.Instance().get(from, false);
+            if (!account) {
+                throw new MessengerError(MessengerErrorCode.IDENTITY_NOT_FOUND, `Account ${from} not found`);
+            }
+            if (account.m == null) {
+                if (options?.new_messenger_name == null) {
+                    throw new MessengerError(MessengerErrorCode.ACCOUNT_MESSENGER_NOT_ENABLED, `Account messenger name not set. Use new_messenger_name parameter to set it automatically.`);
+                }
+                await Account.Instance().set_messenger(from, options.new_messenger_name);
             }
-            if (includeAddresses && includeAddresses.length > 0) {
-              const includeSet = new Set(
-                includeAddresses.map((a) => a.toLowerCase())
-              );
-              const inIncludeList = includeSet.has(senderAddress);
-              if (relation === "union") {
-                const modeMatch = filter.listFilterMode === "friends" && inFriends || filter.listFilterMode === "guard" && inGuards || filter.listFilterMode === "stranger" && isStranger;
-                if (!inIncludeList && !modeMatch) return false;
-              } else {
-                if (!inIncludeList) return false;
-              }
+            await this.refresh_accounts();
+            accountInfo = this.findAccount(from);
+            if (!accountInfo) {
+                throw new MessengerError(MessengerErrorCode.SERVER_ERROR, `Failed to add account ${from} to messenger manager`);
             }
-          }
         }
-        return true;
-      });
-    }
-    const sortOrder = filter?.sortOrder ?? "desc";
-    const sortField = filter?.timeField || "createdAt";
-    messages.sort((a, b) => {
-      const aTime = a[sortField] || 0;
-      const bTime = b[sortField] || 0;
-      return sortOrder === "asc" ? aTime - bTime : bTime - aTime;
-    });
-    const { MAX_QUERY_LIMIT } = await import("./types.js");
-    const defaultLimit = this.config.defaultQueryLimit ?? 50;
-    const limit = Math.min(filter?.limit ?? defaultLimit, MAX_QUERY_LIMIT);
-    const offset = filter?.offset ?? 0;
-    messages = messages.slice(offset, offset + limit);
-    return messages;
-  }
-  startPolling() {
-    if (this.isWatching) return;
-    this.isWatching = true;
-    for (const info of this.accounts.values()) {
-      const timer = setInterval(async () => {
-        try {
-          const messages = await info.messenger.pullMessages();
-          if (messages.length > 0) {
-            for (const listener of this.messageListeners) {
-              listener(messages);
+        if (options?.new_messenger_name != null) {
+            const account = await Account.Instance().get(from, false);
+            if (account && account.m !== options.new_messenger_name) {
+                await Account.Instance().set_messenger(from, options.new_messenger_name);
             }
-          }
-        } catch (error) {
-          console.error(
-            `Failed to poll messages for ${info.address}:`,
-            error
-          );
         }
-      }, this.config.watch_interval_ms);
-      this.pollingTimers.set(info.address, timer);
-    }
-  }
-  startAccountPolling(address) {
-    const info = this.accounts.get(address.toLowerCase());
-    if (!info || !info.initialized) return;
-    const existingTimer = this.pollingTimers.get(info.address);
-    if (existingTimer) {
-      clearInterval(existingTimer);
+        return accountInfo.messenger.sendZipFile(to, filePath, {
+            fileName: options?.fileName,
+            contentType: options?.contentType,
+            guardAddress: options?.guardAddress,
+            passportAddress: options?.passportAddress,
+            force: options?.force,
+        });
     }
-    const timer = setInterval(async () => {
-      try {
-        const messages = await info.messenger.pullMessages();
-        if (messages.length > 0) {
-          for (const listener of this.messageListeners) {
-            listener(messages);
-          }
+    async watch(filter) {
+        let messages = [];
+        if (filter?.account) {
+            const address = filter.account.toLowerCase();
+            const messageStorage = new MessageStorage(address);
+            messages = messageStorage.getAllMessages(address);
+        }
+        else {
+            for (const account of this.accounts.values()) {
+                const messageStorage = new MessageStorage(account.address);
+                const accountMessages = messageStorage.getAllMessages(account.address);
+                messages.push(...accountMessages);
+            }
         }
-      } catch (error) {
-        console.error(
-          `Failed to poll messages for ${info.address}:`,
-          error
-        );
-      }
-    }, this.config.watch_interval_ms);
-    this.pollingTimers.set(info.address, timer);
-  }
-  stopPolling() {
-    for (const timer of this.pollingTimers.values()) {
-      clearInterval(timer);
+        if (filter) {
+            const peerAddress = filter.peerAddress
+                ? await GetAccountOrMark_Address(filter.peerAddress)
+                : undefined;
+            messages = messages.filter((msg) => {
+                if (filter.account) {
+                    const accountLower = filter.account.toLowerCase();
+                    const fromLower = msg.fromAddress.toLowerCase();
+                    const toLower = msg.toAddress.toLowerCase();
+                    if (fromLower !== accountLower &&
+                        toLower !== accountLower) {
+                        return false;
+                    }
+                }
+                if (filter.direction && msg.direction !== filter.direction) {
+                    return false;
+                }
+                if (filter.status && msg.status !== filter.status) {
+                    return false;
+                }
+                if (filter.msgType !== undefined &&
+                    msg.msgType !== filter.msgType) {
+                    return false;
+                }
+                if (filter.contentType) {
+                    switch (filter.contentType) {
+                        case "text":
+                            if (msg.msgType !== MessageType.NORMAL_MESSAGE)
+                                return false;
+                            break;
+                        case "zip":
+                            if (!msg.zipMetadata)
+                                return false;
+                            break;
+                        case "wts":
+                            if (!msg.zipMetadata ||
+                                msg.zipMetadata?.contentType !== "wts") {
+                                return false;
+                            }
+                            break;
+                        case "wip":
+                            if (!msg.zipMetadata ||
+                                msg.zipMetadata?.contentType !== "wip") {
+                                return false;
+                            }
+                            break;
+                    }
+                }
+                if (filter.peerAddress && peerAddress) {
+                    const peer = peerAddress.toLowerCase();
+                    const from = msg.fromAddress.toLowerCase();
+                    const to = msg.toAddress.toLowerCase();
+                    if (from !== peer && to !== peer) {
+                        return false;
+                    }
+                }
+                const timeField = filter.timeField || "createdAt";
+                if (filter.startTime !== undefined ||
+                    filter.endTime !== undefined) {
+                    const msgTime = msg[timeField];
+                    if (msgTime !== undefined) {
+                        if (filter.startTime !== undefined &&
+                            msgTime < filter.startTime) {
+                            return false;
+                        }
+                        if (filter.endTime !== undefined &&
+                            msgTime > filter.endTime) {
+                            return false;
+                        }
+                    }
+                }
+                if (filter.createdAtStart !== undefined &&
+                    msg.createdAt < filter.createdAtStart) {
+                    return false;
+                }
+                if (filter.createdAtEnd !== undefined &&
+                    msg.createdAt > filter.createdAtEnd) {
+                    return false;
+                }
+                if (filter.receivedAtStart !== undefined) {
+                    if (msg.receivedAt === undefined ||
+                        msg.receivedAt < filter.receivedAtStart) {
+                        return false;
+                    }
+                }
+                if (filter.receivedAtEnd !== undefined) {
+                    if (msg.receivedAt === undefined ||
+                        msg.receivedAt > filter.receivedAtEnd) {
+                        return false;
+                    }
+                }
+                if (filter.serverTimestampStart !== undefined) {
+                    if (msg.serverTimestamp === undefined ||
+                        msg.serverTimestamp < filter.serverTimestampStart) {
+                        return false;
+                    }
+                }
+                if (filter.serverTimestampEnd !== undefined) {
+                    if (msg.serverTimestamp === undefined ||
+                        msg.serverTimestamp > filter.serverTimestampEnd) {
+                        return false;
+                    }
+                }
+                if (filter.decryptedOnly && !msg.plaintext) {
+                    return false;
+                }
+                if (filter.arkConfirmedOnly) {
+                    if (!msg.arkConfirmed) {
+                        return false;
+                    }
+                }
+                if (filter.proofedOnly) {
+                    if (!msg.proof) {
+                        return false;
+                    }
+                }
+                if (filter.arkTimestampStart !== undefined) {
+                    if (msg.arkConfirmed === undefined ||
+                        msg.arkConfirmed.timestamp < filter.arkTimestampStart) {
+                        return false;
+                    }
+                }
+                if (filter.arkTimestampEnd !== undefined) {
+                    if (msg.arkConfirmed === undefined ||
+                        msg.arkConfirmed.timestamp > filter.arkTimestampEnd) {
+                        return false;
+                    }
+                }
+                if (filter.hasLastReceivedIndexOnly) {
+                    if (msg.lastReceivedLeafIndex === undefined ||
+                        msg.lastReceivedLeafIndex === null) {
+                        return false;
+                    }
+                }
+                if (filter.lastReceivedIndexMin !== undefined) {
+                    if (msg.lastReceivedLeafIndex === undefined ||
+                        msg.lastReceivedLeafIndex < filter.lastReceivedIndexMin) {
+                        return false;
+                    }
+                }
+                if (filter.lastReceivedIndexMax !== undefined) {
+                    if (msg.lastReceivedLeafIndex === undefined ||
+                        msg.lastReceivedLeafIndex > filter.lastReceivedIndexMax) {
+                        return false;
+                    }
+                }
+                if (filter.keyword && msg.plaintext) {
+                    if (!msg.plaintext
+                        .toLowerCase()
+                        .includes(filter.keyword.toLowerCase())) {
+                        return false;
+                    }
+                }
+                if (filter.listFilterMode && filter.listFilterMode !== "any") {
+                    const msgAccount = this.findAccount(msg.toAddress);
+                    if (!msgAccount)
+                        return false;
+                    const senderAddress = msg.fromAddress.toLowerCase();
+                    const lists = msgAccount.contactLists;
+                    const friends = new Set(lists.friends.map((a) => a.toLowerCase()));
+                    const guards = new Set(lists.guards.map((g) => g.guardAddress.toLowerCase()));
+                    const inFriends = friends.has(senderAddress);
+                    const inGuards = guards.has(senderAddress);
+                    const isStranger = !inFriends && !inGuards;
+                    switch (filter.listFilterMode) {
+                        case "friends":
+                            if (!inFriends)
+                                return false;
+                            break;
+                        case "guard":
+                            if (!inGuards)
+                                return false;
+                            break;
+                        case "stranger":
+                            if (!isStranger)
+                                return false;
+                            break;
+                    }
+                    if (filter.customListFilter) {
+                        const { includeAddresses, excludeAddresses, relation = "union", } = filter.customListFilter;
+                        if (excludeAddresses) {
+                            const excludeSet = new Set(excludeAddresses.map((a) => a.toLowerCase()));
+                            if (excludeSet.has(senderAddress))
+                                return false;
+                        }
+                        if (includeAddresses && includeAddresses.length > 0) {
+                            const includeSet = new Set(includeAddresses.map((a) => a.toLowerCase()));
+                            const inIncludeList = includeSet.has(senderAddress);
+                            if (relation === "union") {
+                                const modeMatch = (filter.listFilterMode === "friends" &&
+                                    inFriends) ||
+                                    (filter.listFilterMode === "guard" &&
+                                        inGuards) ||
+                                    (filter.listFilterMode === "stranger" &&
+                                        isStranger);
+                                if (!inIncludeList && !modeMatch)
+                                    return false;
+                            }
+                            else {
+                                if (!inIncludeList)
+                                    return false;
+                            }
+                        }
+                    }
+                }
+                return true;
+            });
+        }
+        const sortOrder = filter?.sortOrder ?? "desc";
+        const sortField = filter?.timeField || "createdAt";
+        messages.sort((a, b) => {
+            const aTime = a[sortField] || 0;
+            const bTime = b[sortField] || 0;
+            return sortOrder === "asc" ? aTime - bTime : bTime - aTime;
+        });
+        const { MAX_QUERY_LIMIT } = await import("./types.js");
+        const defaultLimit = this.config.defaultQueryLimit ?? 50;
+        const limit = Math.min(filter?.limit ?? defaultLimit, MAX_QUERY_LIMIT);
+        const offset = filter?.offset ?? 0;
+        messages = messages.slice(offset, offset + limit);
+        return messages;
+    }
+    startPolling() {
+        if (this.isWatching)
+            return;
+        this.isWatching = true;
+        for (const info of this.accounts.values()) {
+            const timer = setInterval(async () => {
+                try {
+                    const messages = await info.messenger.pullMessages();
+                    if (messages.length > 0) {
+                        for (const listener of this.messageListeners) {
+                            listener(messages);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to poll messages for ${info.address}:`, error);
+                }
+            }, this.config.watch_interval_ms);
+            this.pollingTimers.set(info.address, timer);
+        }
+    }
+    startAccountPolling(address) {
+        const info = this.accounts.get(address.toLowerCase());
+        if (!info || !info.initialized)
+            return;
+        const existingTimer = this.pollingTimers.get(info.address);
+        if (existingTimer) {
+            clearInterval(existingTimer);
+        }
+        const timer = setInterval(async () => {
+            try {
+                const messages = await info.messenger.pullMessages();
+                if (messages.length > 0) {
+                    for (const listener of this.messageListeners) {
+                        listener(messages);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Failed to poll messages for ${info.address}:`, error);
+            }
+        }, this.config.watch_interval_ms);
+        this.pollingTimers.set(info.address, timer);
     }
-    this.pollingTimers.clear();
-    this.isWatching = false;
-  }
-  onMessage(listener) {
-    this.messageListeners.add(listener);
-  }
-  offMessage(listener) {
-    this.messageListeners.delete(listener);
-  }
-  destroy() {
-    this.stop();
-    this.messageListeners.clear();
-  }
-  async syncContactLists(account) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      return {
-        success: false,
-        friends: [],
-        guards: [],
-        error: `Account not found: ${account}`
-      };
+    stopPolling() {
+        for (const timer of this.pollingTimers.values()) {
+            clearInterval(timer);
+        }
+        this.pollingTimers.clear();
+        this.isWatching = false;
     }
-    try {
-      const { Account } = await import("../local/account.js");
-      const accountData = await Account.Instance().get(account, false);
-      if (!accountData?.address) {
-        return {
-          success: false,
-          friends: [],
-          guards: [],
-          error: `Account data not found: ${account}`
-        };
-      }
-      const address = accountData.address;
-      const [friends, guards] = await Promise.all([
-        this.fetchFriendsList(address),
-        this.fetchGuardList(address)
-      ]);
-      acc.contactLists = {
-        friends,
-        guards,
-        lastUpdatedAt: Date.now()
-      };
-      return {
-        success: true,
-        friends,
-        guards
-      };
-    } catch (error) {
-      console.error(
-        `Failed to sync contact lists for ${account}:`,
-        error
-      );
-      return {
-        success: false,
-        friends: acc.contactLists.friends,
-        guards: acc.contactLists.guards,
-        error: error instanceof Error ? error.message : String(error)
-      };
+    onMessage(listener) {
+        this.messageListeners.add(listener);
     }
-  }
-  async syncAllContactLists() {
-    const results = /* @__PURE__ */ new Map();
-    for (const acc of this.accounts.values()) {
-      const result = await this.syncContactLists(acc.address);
-      results.set(acc.address, result);
+    offMessage(listener) {
+        this.messageListeners.delete(listener);
     }
-    return results;
-  }
-  getContactLists(account) {
-    const acc = this.findAccount(account);
-    return acc?.contactLists;
-  }
-  setContactLists(account, lists) {
-    const acc = this.findAccount(account);
-    if (!acc) return false;
-    acc.contactLists = {
-      ...acc.contactLists,
-      ...lists,
-      lastUpdatedAt: Date.now()
-    };
-    return true;
-  }
-  isStranger(account, senderAddress) {
-    const acc = this.findAccount(account);
-    if (!acc) return true;
-    const sender = senderAddress.toLowerCase();
-    const lists = acc.contactLists;
-    const inFriends = lists.friends.some((a) => a.toLowerCase() === sender);
-    const inGuards = lists.guards.some(
-      (g) => g.guardAddress.toLowerCase() === sender
-    );
-    return !inFriends && !inGuards;
-  }
-  recordGuardSender(account, guardAddress) {
-    const acc = this.findAccount(account);
-    if (!acc) return false;
-    const guardAddr = guardAddress.toLowerCase();
-    const exists = acc.contactLists.guards.some(
-      (g) => g.guardAddress.toLowerCase() === guardAddr
-    );
-    if (!exists) {
-      acc.contactLists.guards.push({
-        guardAddress,
-        passportValiditySeconds: 86400
-      });
-      acc.contactLists.lastUpdatedAt = Date.now();
+    destroy() {
+        this.stop();
+        this.messageListeners.clear();
     }
-    return true;
-  }
-  async fetchFriendsList(address) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/spam-protection/${address}/friends-list`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            userAddress: address,
-            signature: "",
-            timestamp: Date.now(),
-            nonce: this.generateNonce()
-          })
+    async syncContactLists(account) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            return {
+                success: false,
+                friends: [],
+                guards: [],
+                error: `Account not found: ${account}`,
+            };
         }
-      );
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      return await response.json();
-    } catch (error) {
-      return [];
+        try {
+            const { Account } = await import("../local/account.js");
+            const accountData = await Account.Instance().get(account, false);
+            if (!accountData?.address) {
+                return {
+                    success: false,
+                    friends: [],
+                    guards: [],
+                    error: `Account data not found: ${account}`,
+                };
+            }
+            const address = accountData.address;
+            const [friends, guards] = await Promise.all([
+                this.fetchFriendsList(address),
+                this.fetchGuardList(address),
+            ]);
+            acc.contactLists = {
+                friends,
+                guards,
+                lastUpdatedAt: Date.now(),
+            };
+            return {
+                success: true,
+                friends,
+                guards,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to sync contact lists for ${account}:`, error);
+            return {
+                success: false,
+                friends: acc.contactLists.friends,
+                guards: acc.contactLists.guards,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async syncAllContactLists() {
+        const results = new Map();
+        for (const acc of this.accounts.values()) {
+            const result = await this.syncContactLists(acc.address);
+            results.set(acc.address, result);
+        }
+        return results;
+    }
+    getContactLists(account) {
+        const acc = this.findAccount(account);
+        return acc?.contactLists;
+    }
+    setContactLists(account, lists) {
+        const acc = this.findAccount(account);
+        if (!acc)
+            return false;
+        acc.contactLists = {
+            ...acc.contactLists,
+            ...lists,
+            lastUpdatedAt: Date.now(),
+        };
+        return true;
     }
-  }
-  async fetchGuardList(address) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/spam-protection/${address}/guard-list`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            userAddress: address,
-            signature: "",
-            timestamp: Date.now(),
-            nonce: this.generateNonce()
-          })
+    isStranger(account, senderAddress) {
+        const acc = this.findAccount(account);
+        if (!acc)
+            return true;
+        const sender = senderAddress.toLowerCase();
+        const lists = acc.contactLists;
+        const inFriends = lists.friends.some((a) => a.toLowerCase() === sender);
+        const inGuards = lists.guards.some((g) => g.guardAddress.toLowerCase() === sender);
+        return !inFriends && !inGuards;
+    }
+    recordGuardSender(account, guardAddress) {
+        const acc = this.findAccount(account);
+        if (!acc)
+            return false;
+        const guardAddr = guardAddress.toLowerCase();
+        const exists = acc.contactLists.guards.some((g) => g.guardAddress.toLowerCase() === guardAddr);
+        if (!exists) {
+            acc.contactLists.guards.push({
+                guardAddress: guardAddress,
+                passportValiditySeconds: 86400,
+            });
+            acc.contactLists.lastUpdatedAt = Date.now();
         }
-      );
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      return await response.json();
-    } catch (error) {
-      return [];
-    }
-  }
-  generateNonce() {
-    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-  }
-  async watch_paginated(filter) {
-    const { MAX_QUERY_LIMIT } = await import("./types.js");
-    const allMessages = await this.watch(filter);
-    const total = allMessages.length;
-    const defaultLimit = this.config.defaultQueryLimit ?? 50;
-    const limit = Math.min(filter?.limit ?? defaultLimit, MAX_QUERY_LIMIT);
-    const offset = filter?.offset ?? 0;
-    const messages = allMessages.slice(offset, offset + limit);
-    return {
-      messages,
-      total,
-      offset,
-      limit
-    };
-  }
-  async get_conversations(account) {
-    const filter = account ? { account } : void 0;
-    const allMessages = await this.watch(filter);
-    const conversations = /* @__PURE__ */ new Map();
-    for (const msg of allMessages) {
-      const myAddress = account?.toLowerCase();
-      const peerAddress = msg.fromAddress.toLowerCase() === myAddress ? msg.toAddress : msg.fromAddress;
-      if (!conversations.has(peerAddress)) {
-        conversations.set(peerAddress, {
-          peerAddress,
-          lastMessageAt: msg.createdAt,
-          messageCount: 0,
-          unreadCount: 0,
-          lastMessagePreview: msg.plaintext
-        });
-      }
-      const conv = conversations.get(peerAddress);
-      conv.messageCount++;
-      if (msg.createdAt > conv.lastMessageAt) {
-        conv.lastMessageAt = msg.createdAt;
-        conv.lastMessagePreview = msg.plaintext;
-      }
-      if (msg.status !== MessageStatus.READ && msg.toAddress.toLowerCase() === myAddress) {
-        conv.unreadCount++;
-      }
-    }
-    return Array.from(conversations.values()).sort(
-      (a, b) => b.lastMessageAt - a.lastMessageAt
-    );
-  }
-  async generate_wts(params) {
-    const fs = await import("fs");
-    const path = await import("path");
-    const myAddress = params.myAccount.toLowerCase();
-    const peerAddress = params.peerAccount.toLowerCase();
-    const messageStorage = new MessageStorage(myAddress);
-    const myMessages = messageStorage.getAllMessages(myAddress);
-    let messages = myMessages.filter((msg) => {
-      const fromLower = msg.fromAddress.toLowerCase();
-      const toLower = msg.toAddress.toLowerCase();
-      const isBetween = fromLower === myAddress && toLower === peerAddress || fromLower === peerAddress && toLower === myAddress;
-      return isBetween;
-    });
-    messages = messages.filter(
-      (m) => m.leafIndex !== void 0 && m.serverTimestamp !== void 0
-    ).reduce((acc, msg) => {
-      const existing = acc.find((m) => m.messageId === msg.messageId);
-      if (!existing) {
-        acc.push(msg);
-      }
-      return acc;
-    }, []).sort((a, b) => {
-      return a.leafIndex - b.leafIndex;
-    });
-    const leafIndexMap = /* @__PURE__ */ new Map();
-    for (const msg of messages) {
-      const idx = msg.leafIndex;
-      if (!leafIndexMap.has(idx)) {
-        leafIndexMap.set(idx, []);
-      }
-      leafIndexMap.get(idx).push(msg);
+        return true;
     }
-    const duplicates = Array.from(leafIndexMap.entries()).filter(
-      ([, msgs]) => msgs.length > 1
-    );
-    if (duplicates.length > 0) {
-      messages.sort(
-        (a, b) => (b.serverTimestamp || 0) - (a.serverTimestamp || 0)
-      );
-      const seenLeafIndices = /* @__PURE__ */ new Set();
-      const uniqueMessages = [];
-      for (const msg of messages) {
-        const idx = msg.leafIndex;
-        if (!seenLeafIndices.has(idx)) {
-          seenLeafIndices.add(idx);
-          uniqueMessages.push(msg);
+    async fetchFriendsList(address) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${address}/friends-list`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    userAddress: address,
+                    signature: "",
+                    timestamp: Date.now(),
+                    nonce: this.generateNonce(),
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return (await response.json());
         }
-      }
-      messages = uniqueMessages.sort(
-        (a, b) => a.leafIndex - b.leafIndex
-      );
-    }
-    if (params.range) {
-      switch (params.range.type) {
-        case "time": {
-          const start = Math.min(
-            params.range.start,
-            params.range.end
-          );
-          const end = Math.max(params.range.start, params.range.end);
-          messages = messages.filter(
-            (m) => m.createdAt >= start && m.createdAt <= end
-          );
-          break;
+        catch (error) {
+            return [];
         }
-        case "messageId": {
-          const start = params.range.start;
-          const end = params.range.end;
-          messages = messages.filter(
-            (m) => m.messageId >= start && m.messageId <= end
-          );
-          break;
+    }
+    async fetchGuardList(address) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${address}/guard-list`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    userAddress: address,
+                    signature: "",
+                    timestamp: Date.now(),
+                    nonce: this.generateNonce(),
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return (await response.json());
         }
-        case "seqIndex": {
-          const start = Math.min(
-            params.range.start,
-            params.range.end
-          );
-          const end = Math.max(params.range.start, params.range.end);
-          messages = messages.filter(
-            (m) => m.leafIndex >= start && m.leafIndex <= end
-          );
-          break;
+        catch (error) {
+            return [];
         }
-      }
-    }
-    if (messages.length === 0) {
-      throw new MessengerError(
-        MessengerErrorCode.INVALID_INPUT,
-        "No messages found for the given criteria"
-      );
     }
-    if (messages.length > WTS_MAX_MESSAGE_COUNT) {
-      throw new MessengerError(
-        MessengerErrorCode.INVALID_INPUT,
-        `Message count (${messages.length}) exceeds maximum allowed (${WTS_MAX_MESSAGE_COUNT})`
-      );
+    generateNonce() {
+        return (Math.random().toString(36).substring(2, 15) +
+            Math.random().toString(36).substring(2, 15));
     }
-    if (!fs.existsSync(params.outputDir)) {
-      fs.mkdirSync(params.outputDir, { recursive: true });
+    async watch_paginated(filter) {
+        const { MAX_QUERY_LIMIT } = await import("./types.js");
+        const allMessages = await this.watch(filter);
+        const total = allMessages.length;
+        const defaultLimit = this.config.defaultQueryLimit ?? 50;
+        const limit = Math.min(filter?.limit ?? defaultLimit, MAX_QUERY_LIMIT);
+        const offset = filter?.offset ?? 0;
+        const messages = allMessages.slice(offset, offset + limit);
+        return {
+            messages,
+            total,
+            offset,
+            limit,
+        };
     }
-    const sessionId = `${myAddress.slice(0, 6)}_${peerAddress.slice(0, 6)}`;
-    const groups = [messages];
-    const generatedFiles = [];
-    const startTime = messages[0].createdAt;
-    const endTime = messages[messages.length - 1].createdAt;
-    for (const group of groups) {
-      const leafIndices = group.map((m) => m.leafIndex).filter((i) => i !== void 0);
-      const startLeafIndex = Math.min(...leafIndices);
-      const endLeafIndex = Math.max(...leafIndices);
-      for (const msg of group) {
-        if (msg.serverTimestamp === void 0) {
-          throw new MessengerError(
-            MessengerErrorCode.INVALID_INPUT,
-            `Message ${msg.messageId} missing serverTimestamp`
-          );
-        }
-        if (msg.leafIndex === void 0) {
-          throw new MessengerError(
-            MessengerErrorCode.INVALID_INPUT,
-            `Message ${msg.messageId} missing leafIndex`
-          );
-        }
-        if (!msg.prevRoot) {
-          throw new MessengerError(
-            MessengerErrorCode.INVALID_INPUT,
-            `Message ${msg.messageId} missing prevRoot`
-          );
+    async get_conversations(account) {
+        const filter = account ? { account } : undefined;
+        const allMessages = await this.watch(filter);
+        const conversations = new Map();
+        for (const msg of allMessages) {
+            const myAddress = account?.toLowerCase();
+            const peerAddress = msg.fromAddress.toLowerCase() === myAddress
+                ? msg.toAddress
+                : msg.fromAddress;
+            if (!conversations.has(peerAddress)) {
+                conversations.set(peerAddress, {
+                    peerAddress,
+                    lastMessageAt: msg.createdAt,
+                    messageCount: 0,
+                    unreadCount: 0,
+                    lastMessagePreview: msg.plaintext,
+                });
+            }
+            const conv = conversations.get(peerAddress);
+            conv.messageCount++;
+            if (msg.createdAt > conv.lastMessageAt) {
+                conv.lastMessageAt = msg.createdAt;
+                conv.lastMessagePreview = msg.plaintext;
+            }
+            if (msg.status !== MessageStatus.READ &&
+                msg.toAddress.toLowerCase() === myAddress) {
+                conv.unreadCount++;
+            }
         }
-        if (!msg.newRoot) {
-          throw new MessengerError(
-            MessengerErrorCode.INVALID_INPUT,
-            `Message ${msg.messageId} missing newRoot`
-          );
+        return Array.from(conversations.values()).sort((a, b) => b.lastMessageAt - a.lastMessageAt);
+    }
+    async generate_wts(params) {
+        const fs = await import("fs");
+        const path = await import("path");
+        const myAddress = params.myAccount.toLowerCase();
+        const peerAddress = params.peerAccount.toLowerCase();
+        const messageStorage = new MessageStorage(myAddress);
+        const myMessages = messageStorage.getAllMessages(myAddress);
+        let messages = myMessages.filter((msg) => {
+            const fromLower = msg.fromAddress.toLowerCase();
+            const toLower = msg.toAddress.toLowerCase();
+            const isBetween = (fromLower === myAddress && toLower === peerAddress) ||
+                (fromLower === peerAddress && toLower === myAddress);
+            return isBetween;
+        });
+        messages = messages
+            .filter((m) => m.leafIndex !== undefined &&
+            m.serverTimestamp !== undefined)
+            .reduce((acc, msg) => {
+            const existing = acc.find((m) => m.messageId === msg.messageId);
+            if (!existing) {
+                acc.push(msg);
+            }
+            return acc;
+        }, [])
+            .sort((a, b) => {
+            return a.leafIndex - b.leafIndex;
+        });
+        const leafIndexMap = new Map();
+        for (const msg of messages) {
+            const idx = msg.leafIndex;
+            if (!leafIndexMap.has(idx)) {
+                leafIndexMap.set(idx, []);
+            }
+            leafIndexMap.get(idx).push(msg);
+        }
+        const duplicates = Array.from(leafIndexMap.entries()).filter(([, msgs]) => msgs.length > 1);
+        if (duplicates.length > 0) {
+            messages.sort((a, b) => (b.serverTimestamp || 0) - (a.serverTimestamp || 0));
+            const seenLeafIndices = new Set();
+            const uniqueMessages = [];
+            for (const msg of messages) {
+                const idx = msg.leafIndex;
+                if (!seenLeafIndices.has(idx)) {
+                    seenLeafIndices.add(idx);
+                    uniqueMessages.push(msg);
+                }
+            }
+            messages = uniqueMessages.sort((a, b) => a.leafIndex - b.leafIndex);
+        }
+        if (params.range) {
+            switch (params.range.type) {
+                case "time": {
+                    const start = Math.min(params.range.start, params.range.end);
+                    const end = Math.max(params.range.start, params.range.end);
+                    messages = messages.filter((m) => m.createdAt >= start && m.createdAt <= end);
+                    break;
+                }
+                case "messageId": {
+                    const start = params.range.start;
+                    const end = params.range.end;
+                    messages = messages.filter((m) => m.messageId >= start && m.messageId <= end);
+                    break;
+                }
+                case "seqIndex": {
+                    const start = Math.min(params.range.start, params.range.end);
+                    const end = Math.max(params.range.start, params.range.end);
+                    messages = messages.filter((m) => m.leafIndex >= start && m.leafIndex <= end);
+                    break;
+                }
+            }
         }
-        if (!msg.serverSignature) {
-          throw new MessengerError(
-            MessengerErrorCode.INVALID_INPUT,
-            `Message ${msg.messageId} missing serverSignature`
-          );
+        if (messages.length === 0) {
+            throw new MessengerError(MessengerErrorCode.INVALID_INPUT, "No messages found for the given criteria");
+        }
+        if (messages.length > WTS_MAX_MESSAGE_COUNT) {
+            throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message count (${messages.length}) exceeds maximum allowed (${WTS_MAX_MESSAGE_COUNT})`);
+        }
+        if (!fs.existsSync(params.outputDir)) {
+            fs.mkdirSync(params.outputDir, { recursive: true });
+        }
+        const sessionId = `${myAddress.slice(0, 6)}_${peerAddress.slice(0, 6)}`;
+        const groups = [messages];
+        const generatedFiles = [];
+        const startTime = messages[0].createdAt;
+        const endTime = messages[messages.length - 1].createdAt;
+        for (const group of groups) {
+            const leafIndices = group
+                .map((m) => m.leafIndex)
+                .filter((i) => i !== undefined);
+            const startLeafIndex = Math.min(...leafIndices);
+            const endLeafIndex = Math.max(...leafIndices);
+            for (const msg of group) {
+                if (msg.serverTimestamp === undefined) {
+                    throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message ${msg.messageId} missing serverTimestamp`);
+                }
+                if (msg.leafIndex === undefined) {
+                    throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message ${msg.messageId} missing leafIndex`);
+                }
+                if (!msg.prevRoot) {
+                    throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message ${msg.messageId} missing prevRoot`);
+                }
+                if (!msg.newRoot) {
+                    throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message ${msg.messageId} missing newRoot`);
+                }
+                if (!msg.serverSignature) {
+                    throw new MessengerError(MessengerErrorCode.INVALID_INPUT, `Message ${msg.messageId} missing serverSignature`);
+                }
+            }
+            const wtsMessages = group.map((msg) => ({
+                id: msg.messageId,
+                from: msg.fromAddress,
+                to: msg.toAddress,
+                plaintext: params.excludePlaintext ? undefined : msg.plaintext,
+                plaintextHash: msg.plaintextHash,
+                clientTimestamp: msg.createdAt,
+                timestamp: msg.serverTimestamp,
+                leafIndex: msg.leafIndex,
+                prevRoot: msg.prevRoot,
+                merkleRoot: msg.newRoot,
+                serverSignature: msg.serverSignature,
+                serverPublicKey: msg.serverPublicKey || "",
+                guardAddress: msg.guardAddress,
+                passportAddress: msg.passportAddress,
+                lastReceivedLeafIndex: msg.lastReceivedLeafIndex,
+                arkConfirmed: msg.arkConfirmed
+                    ? {
+                        recipient: msg.arkConfirmed.recipient,
+                        recipientPublicKey: msg.arkConfirmed.recipientPublicKey,
+                        signature: msg.arkConfirmed.signature,
+                        timestamp: msg.arkConfirmed.timestamp,
+                    }
+                    : undefined,
+                msgType: msg.msgType,
+                zipMetadata: msg.zipMetadata,
+            }));
+            const addresses = [myAddress, peerAddress].sort();
+            const wtsSession = {
+                id: `${addresses[0]}:${addresses[1]}`,
+                participants: addresses,
+            };
+            const payload = {
+                session: wtsSession,
+                messages: wtsMessages,
+            };
+            const wtsMeta = {
+                type: "wts",
+                version: "1.0",
+                created: new Date().toISOString(),
+                hash: "",
+                algorithm: "sha256",
+                startTime,
+                endTime,
+                messageCount: wtsMessages.length,
+                merkleRoot: wtsMessages[wtsMessages.length - 1].merkleRoot,
+            };
+            const wtsFile = {
+                wts: canonicalizeJson(wtsMeta),
+                payload,
+                meta: wtsMeta,
+            };
+            const fileName = `${sessionId}_${startLeafIndex}-${endLeafIndex}.wts`;
+            const filePath = path.join(params.outputDir, fileName);
+            fs.writeFileSync(filePath, JSON.stringify(wtsFile, null, 2));
+            generatedFiles.push(filePath);
         }
-      }
-      const wtsMessages = group.map((msg) => ({
-        id: msg.messageId,
-        from: msg.fromAddress,
-        to: msg.toAddress,
-        plaintext: params.excludePlaintext ? void 0 : msg.plaintext,
-        plaintextHash: msg.plaintextHash,
-        clientTimestamp: msg.createdAt,
-        timestamp: msg.serverTimestamp,
-        leafIndex: msg.leafIndex,
-        prevRoot: msg.prevRoot,
-        merkleRoot: msg.newRoot,
-        serverSignature: msg.serverSignature,
-        serverPublicKey: msg.serverPublicKey || "",
-        guardAddress: msg.guardAddress,
-        passportAddress: msg.passportAddress,
-        lastReceivedLeafIndex: msg.lastReceivedLeafIndex,
-        arkConfirmed: msg.arkConfirmed ? {
-          recipient: msg.arkConfirmed.recipient,
-          recipientPublicKey: msg.arkConfirmed.recipientPublicKey,
-          signature: msg.arkConfirmed.signature,
-          timestamp: msg.arkConfirmed.timestamp
-        } : void 0,
-        msgType: msg.msgType,
-        zipMetadata: msg.zipMetadata
-      }));
-      const addresses = [myAddress, peerAddress].sort();
-      const wtsSession = {
-        id: `${addresses[0]}:${addresses[1]}`,
-        participants: addresses
-      };
-      const payload = {
-        session: wtsSession,
-        messages: wtsMessages
-      };
-      const wtsMeta = {
-        type: "wts",
-        version: "1.0",
-        created: (/* @__PURE__ */ new Date()).toISOString(),
-        hash: "",
-        algorithm: "sha256",
-        startTime,
-        endTime,
-        messageCount: wtsMessages.length,
-        merkleRoot: wtsMessages[wtsMessages.length - 1].merkleRoot
-      };
-      const wtsFile = {
-        wts: canonicalizeJson(wtsMeta),
-        payload,
-        meta: wtsMeta
-      };
-      const fileName = `${sessionId}_${startLeafIndex}-${endLeafIndex}.wts`;
-      const filePath = path.join(params.outputDir, fileName);
-      fs.writeFileSync(filePath, JSON.stringify(wtsFile, null, 2));
-      generatedFiles.push(filePath);
+        return {
+            files: generatedFiles,
+            totalMessageCount: messages.length,
+            timeRange: {
+                start: startTime,
+                end: endTime,
+            },
+        };
     }
-    return {
-      files: generatedFiles,
-      totalMessageCount: messages.length,
-      timeRange: {
-        start: startTime,
-        end: endTime
-      }
-    };
-  }
-  async addToBlacklist(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async addToBlacklist(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.addToBlacklist(addresses);
     }
-    return acc.messenger.addToBlacklist(addresses);
-  }
-  async removeFromBlacklist(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async removeFromBlacklist(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.removeFromBlacklist(addresses);
     }
-    return acc.messenger.removeFromBlacklist(addresses);
-  }
-  async clearBlacklist(account) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async clearBlacklist(account) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.clearBlacklist();
     }
-    return acc.messenger.clearBlacklist();
-  }
-  async getBlacklist(account) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async getBlacklist(account) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.getBlacklist();
     }
-    return acc.messenger.getBlacklist();
-  }
-  async existInBlacklist(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async existInBlacklist(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.existInBlacklist(addresses);
     }
-    return acc.messenger.existInBlacklist(addresses);
-  }
-  async addToFriendsList(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async addToFriendsList(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.addToFriendsList(addresses);
     }
-    return acc.messenger.addToFriendsList(addresses);
-  }
-  async removeFromFriendsList(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async removeFromFriendsList(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.removeFromFriendsList(addresses);
     }
-    return acc.messenger.removeFromFriendsList(addresses);
-  }
-  async clearFriendsList(account) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async clearFriendsList(account) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.clearFriendsList();
     }
-    return acc.messenger.clearFriendsList();
-  }
-  async getFriendsList(account) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async getFriendsList(account) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.getFriendsList();
     }
-    return acc.messenger.getFriendsList();
-  }
-  async existInFriendsList(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async existInFriendsList(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.existInFriendsList(addresses);
     }
-    return acc.messenger.existInFriendsList(addresses);
-  }
-  async addToGuardList(account, guards) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async addToGuardList(account, guards) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.addToGuardList(guards);
     }
-    return acc.messenger.addToGuardList(guards);
-  }
-  async removeFromGuardList(account, addresses) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async removeFromGuardList(account, addresses) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.removeFromGuardList(addresses);
     }
-    return acc.messenger.removeFromGuardList(addresses);
-  }
-  async getGuardList(account) {
-    const acc = this.findAccount(account);
-    if (!acc) {
-      throw new MessengerError(
-        MessengerErrorCode.ACCOUNT_NOT_FOUND,
-        `Account ${account} not in managed accounts`
-      );
+    async getGuardList(account) {
+        const acc = this.findAccount(account);
+        if (!acc) {
+            throw new MessengerError(MessengerErrorCode.ACCOUNT_NOT_FOUND, `Account ${account} not in managed accounts`);
+        }
+        return acc.messenger.getGuardList();
     }
-    return acc.messenger.getGuardList();
-  }
 }
-export {
-  MessengerManager
-};
+//# sourceMappingURL=messenger-manager.js.map