wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1143 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var messenger_manager_exports = {};
+__export(messenger_manager_exports, {
+  MessengerManager: () => MessengerManager
+});
+module.exports = __toCommonJS(messenger_manager_exports);
+var import_messenger = require("./messenger.js");
+var import_storage = require("./storage.js");
+var import_storage2 = require("./storage.js");
+var import_types = require("./types.js");
+var import_types2 = require("./types.js");
+var import_utils = require("./utils.js");
+var import_account = require("../local/account.js");
+var import_local = require("../local/index.js");
+const MAX_ACCOUNTS = import_account.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 = {
+      ...import_types2.DEFAULT_MESSENGER_CONFIG,
+      ...options?.messengerConfig
+    };
+    this.instanceId = options?.instanceId || "default";
+    this.persistStorage = new import_storage2.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 import_types2.MessengerError(
+        import_types2.MessengerErrorCode.INVALID_INPUT,
+        `Maximum ${MAX_ACCOUNTS} accounts allowed`
+      );
+    }
+    const messenger = new import_messenger.Messenger(addressLower, this.config);
+    try {
+      await messenger.initialize();
+    } catch (error) {
+      throw new import_types2.MessengerError(
+        import_types2.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 import_types2.MessengerError(
+          import_types2.MessengerErrorCode.IDENTITY_NOT_FOUND,
+          `Account ${from} not found`
+        );
+      }
+      if (account.m == null) {
+        if (options?.new_messenger_name == null) {
+          throw new import_types2.MessengerError(
+            import_types2.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 import_types2.MessengerError(
+          import_types2.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 import_types2.MessengerError(
+          import_types2.MessengerErrorCode.IDENTITY_NOT_FOUND,
+          `Account ${from} not found`
+        );
+      }
+      if (account.m == null) {
+        if (options?.new_messenger_name == null) {
+          throw new import_types2.MessengerError(
+            import_types2.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 import_types2.MessengerError(
+          import_types2.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 import_storage.MessageStorage(address);
+      messages = messageStorage.getAllMessages(address);
+    } else {
+      for (const account of this.accounts.values()) {
+        const messageStorage = new import_storage.MessageStorage(account.address);
+        const accountMessages = messageStorage.getAllMessages(
+          account.address
+        );
+        messages.push(...accountMessages);
+      }
+    }
+    if (filter) {
+      const peerAddress = filter.peerAddress ? await (0, import_local.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 !== import_types.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;
+            }
+          }
+        }
+        if (filter.createdAtStart !== void 0 && msg.createdAt < filter.createdAtStart) {
+          return false;
+        }
+        if (filter.createdAtEnd !== void 0 && msg.createdAt > filter.createdAtEnd) {
+          return false;
+        }
+        if (filter.receivedAtStart !== void 0) {
+          if (msg.receivedAt === void 0 || msg.receivedAt < filter.receivedAtStart) {
+            return false;
+          }
+        }
+        if (filter.receivedAtEnd !== void 0) {
+          if (msg.receivedAt === void 0 || msg.receivedAt > filter.receivedAtEnd) {
+            return false;
+          }
+        }
+        if (filter.serverTimestampStart !== void 0) {
+          if (msg.serverTimestamp === void 0 || msg.serverTimestamp < filter.serverTimestampStart) {
+            return false;
+          }
+        }
+        if (filter.serverTimestampEnd !== void 0) {
+          if (msg.serverTimestamp === void 0 || 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 !== void 0) {
+          if (msg.arkConfirmed === void 0 || msg.arkConfirmed.timestamp < filter.arkTimestampStart) {
+            return false;
+          }
+        }
+        if (filter.arkTimestampEnd !== void 0) {
+          if (msg.arkConfirmed === void 0 || msg.arkConfirmed.timestamp > filter.arkTimestampEnd) {
+            return false;
+          }
+        }
+        if (filter.hasLastReceivedIndexOnly) {
+          if (msg.lastReceivedLeafIndex === void 0 || msg.lastReceivedLeafIndex === null) {
+            return false;
+          }
+        }
+        if (filter.lastReceivedIndexMin !== void 0) {
+          if (msg.lastReceivedLeafIndex === void 0 || msg.lastReceivedLeafIndex < filter.lastReceivedIndexMin) {
+            return false;
+          }
+        }
+        if (filter.lastReceivedIndexMax !== void 0) {
+          if (msg.lastReceivedLeafIndex === void 0 || 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);
+  }
+  stopPolling() {
+    for (const timer of this.pollingTimers.values()) {
+      clearInterval(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}`
+      };
+    }
+    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 = /* @__PURE__ */ 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;
+  }
+  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();
+    }
+    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()
+          })
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      return await response.json();
+    } catch (error) {
+      return [];
+    }
+  }
+  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();
+    } 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 !== import_types.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 import_storage.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);
+    }
+    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);
+        }
+      }
+      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 (messages.length === 0) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.INVALID_INPUT,
+        "No messages found for the given criteria"
+      );
+    }
+    if (messages.length > import_types.WTS_MAX_MESSAGE_COUNT) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.INVALID_INPUT,
+        `Message count (${messages.length}) exceeds maximum allowed (${import_types.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 !== void 0);
+      const startLeafIndex = Math.min(...leafIndices);
+      const endLeafIndex = Math.max(...leafIndices);
+      for (const msg of group) {
+        if (msg.serverTimestamp === void 0) {
+          throw new import_types2.MessengerError(
+            import_types2.MessengerErrorCode.INVALID_INPUT,
+            `Message ${msg.messageId} missing serverTimestamp`
+          );
+        }
+        if (msg.leafIndex === void 0) {
+          throw new import_types2.MessengerError(
+            import_types2.MessengerErrorCode.INVALID_INPUT,
+            `Message ${msg.messageId} missing leafIndex`
+          );
+        }
+        if (!msg.prevRoot) {
+          throw new import_types2.MessengerError(
+            import_types2.MessengerErrorCode.INVALID_INPUT,
+            `Message ${msg.messageId} missing prevRoot`
+          );
+        }
+        if (!msg.newRoot) {
+          throw new import_types2.MessengerError(
+            import_types2.MessengerErrorCode.INVALID_INPUT,
+            `Message ${msg.messageId} missing newRoot`
+          );
+        }
+        if (!msg.serverSignature) {
+          throw new import_types2.MessengerError(
+            import_types2.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 ? 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: (0, import_utils.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
+      }
+    };
+  }
+  async addToBlacklist(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.addToBlacklist(addresses);
+  }
+  async removeFromBlacklist(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.removeFromBlacklist(addresses);
+  }
+  async clearBlacklist(account) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.clearBlacklist();
+  }
+  async getBlacklist(account) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.getBlacklist();
+  }
+  async existInBlacklist(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.existInBlacklist(addresses);
+  }
+  async addToFriendsList(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.addToFriendsList(addresses);
+  }
+  async removeFromFriendsList(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.removeFromFriendsList(addresses);
+  }
+  async clearFriendsList(account) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.clearFriendsList();
+  }
+  async getFriendsList(account) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.getFriendsList();
+  }
+  async existInFriendsList(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.existInFriendsList(addresses);
+  }
+  async addToGuardList(account, guards) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.addToGuardList(guards);
+  }
+  async removeFromGuardList(account, addresses) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.removeFromGuardList(addresses);
+  }
+  async getGuardList(account) {
+    const acc = this.findAccount(account);
+    if (!acc) {
+      throw new import_types2.MessengerError(
+        import_types2.MessengerErrorCode.ACCOUNT_NOT_FOUND,
+        `Account ${account} not in managed accounts`
+      );
+    }
+    return acc.messenger.getGuardList();
+  }
+}