wowok 2.1.9 → 2.1.12

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

@@ -1,535 +1,413 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var server_exports = {};
-__export(server_exports, {
-  MessengerServerClient: () => MessengerServerClient,
-  defaultServerClient: () => defaultServerClient
-});
-module.exports = __toCommonJS(server_exports);
-var import_types = require("./types.js");
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultServerClient = exports.MessengerServerClient = void 0;
+const types_js_1 = require("./types.js");
 class MessengerServerClient {
-  constructor(config) {
-    __publicField(this, "config");
-    this.config = { ...import_types.DEFAULT_MESSENGER_CONFIG, ...config };
-  }
-  /**
-   * 注册设备并上传预密钥
-   *
-   * 注意：请求必须包含 wowok 私钥签名，证明地址所有权
-   * 服务器会验证签名并返回详细的上传结果
-   *
-   * 如果身份已存在且密钥一致，会自动追加预密钥，不会报错
-   */
-  async registerDevice(request) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/register`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(request)
+    config;
+    constructor(config) {
+        this.config = { ...types_js_1.DEFAULT_MESSENGER_CONFIG, ...config };
+    }
+    /**
+     * 注册设备并上传预密钥
+     *
+     * 注意：请求必须包含 wowok 私钥签名，证明地址所有权
+     * 服务器会验证签名并返回详细的上传结果
+     *
+     * 如果身份已存在且密钥一致，会自动追加预密钥，不会报错
+     */
+    async registerDevice(request) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/register`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                // 如果是 409 Conflict，可能是身份已存在（需要检查错误信息）
+                if (response.status === 409) {
+                    // 如果错误信息包含 "different key"，说明密钥不一致，这是真正的错误
+                    if (errorText.includes("different key")) {
+                        throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_CONFLICT, `Identity already exists with different key: ${errorText}`);
+                    }
+                    // 否则认为是身份已存在（相同密钥），视为成功
+                    //console.log(`[ServerClient] Identity already exists, treating as success`);
+                    return {
+                        success: true,
+                        uploadedCount: 0,
+                        failedPrekeys: [],
+                        currentTotal: 0,
+                        maxAllowed: 100,
+                    };
+                }
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Registration failed: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+            const data = (await response.json());
+            // 检查是否有预密钥上传失败
+            if (data.failedPrekeys && data.failedPrekeys.length > 0) {
+                /*console.warn(
+                    `[ServerClient] Some prekeys failed to upload:`,
+                    data.failedPrekeys,
+                );*/
+            }
+            return {
+                success: data.success,
+                uploadedCount: data.uploaded_count,
+                failedPrekeys: (data.failed_prekeys ||
+                    []),
+                currentTotal: data.current_total,
+                maxAllowed: data.max_allowed,
+            };
         }
-      );
-      if (!response.ok) {
-        const errorText = await response.text();
-        if (response.status === 409) {
-          if (errorText.includes("different key")) {
-            throw new import_types.MessengerError(
-              import_types.MessengerErrorCode.IDENTITY_CONFLICT,
-              `Identity already exists with different key: ${errorText}`
-            );
-          }
-          return {
-            success: true,
-            uploadedCount: 0,
-            failedPrekeys: [],
-            currentTotal: 0,
-            maxAllowed: 100
-          };
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to register device", error);
         }
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Registration failed: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      const data = await response.json();
-      if (data.failedPrekeys && data.failedPrekeys.length > 0) {
-      }
-      return {
-        success: data.success,
-        uploadedCount: data.uploaded_count,
-        failedPrekeys: data.failed_prekeys || [],
-        currentTotal: data.current_total,
-        maxAllowed: data.max_allowed
-      };
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to register device",
-        error
-      );
     }
-  }
-  /**
-   * 上传额外的预密钥
-   *
-   * 注意：请求必须包含 wowok 私钥签名
-   * 服务器会验证签名并返回详细的上传结果
-   */
-  async uploadPreKeys(request) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/prekeys/upload`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(request)
+    /**
+     * 上传额外的预密钥
+     *
+     * 注意：请求必须包含 wowok 私钥签名
+     * 服务器会验证签名并返回详细的上传结果
+     */
+    async uploadPreKeys(request) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/prekeys/upload`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to upload prekeys: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+            const data = (await response.json());
+            // 检查是否有预密钥上传失败
+            if (data.failedPrekeys && data.failedPrekeys.length > 0) {
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Some prekeys failed to upload: ${JSON.stringify(data.failedPrekeys)}`);
+            }
+            return {
+                success: data.success,
+                uploadedCount: data.uploaded_count,
+                failedPrekeys: (data.failed_prekeys ||
+                    []),
+                currentTotal: data.current_total,
+                maxAllowed: data.max_allowed,
+            };
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to upload prekeys", error);
         }
-      );
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to upload prekeys: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      const data = await response.json();
-      if (data.failedPrekeys && data.failedPrekeys.length > 0) {
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Some prekeys failed to upload: ${JSON.stringify(data.failedPrekeys)}`
-        );
-      }
-      return {
-        success: data.success,
-        uploadedCount: data.uploaded_count,
-        failedPrekeys: data.failed_prekeys || [],
-        currentTotal: data.current_total,
-        maxAllowed: data.max_allowed
-      };
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to upload prekeys",
-        error
-      );
     }
-  }
-  /**
-   * 获取对方的密钥包（用于建立会话）
-   *
-   * 安全要求：必须提供签名验证
-   */
-  async fetchRemoteBundle(userAddress, myAddress, myPublicKey, signatureParams, _deviceId) {
-    try {
-      const queryParams = new URLSearchParams({
-        publicKey: myPublicKey,
-        signatureScheme: signatureParams.signatureScheme,
-        signature: signatureParams.signature,
-        timestamp: signatureParams.timestamp.toString(),
-        nonce: signatureParams.nonce
-      });
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/bundle/${userAddress}?${queryParams}`
-      );
-      if (!response.ok) {
-        if (response.status === 404) {
-          throw new import_types.MessengerError(
-            import_types.MessengerErrorCode.IDENTITY_NOT_FOUND,
-            `User ${userAddress} not found on server`
-          );
+    /**
+     * 获取对方的密钥包（用于建立会话）
+     *
+     * 安全要求：必须提供签名验证
+     */
+    async fetchRemoteBundle(userAddress, myAddress, myPublicKey, signatureParams, _deviceId) {
+        try {
+            // 构建查询参数
+            const queryParams = new URLSearchParams({
+                publicKey: myPublicKey,
+                signatureScheme: signatureParams.signatureScheme,
+                signature: signatureParams.signature,
+                timestamp: signatureParams.timestamp.toString(),
+                nonce: signatureParams.nonce,
+            });
+            const response = await fetch(`${this.config.serverUrl}/v1/bundle/${userAddress}?${queryParams}`);
+            if (!response.ok) {
+                if (response.status === 404) {
+                    throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.IDENTITY_NOT_FOUND, `User ${userAddress} not found on server`);
+                }
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to fetch remote bundle: ${response.statusText}`);
+            }
+            const bundle = (await response.json());
+            /*console.log(
+                `[SERVER DEBUG] fetchRemoteBundle response:`,
+                JSON.stringify(bundle, null, 2),
+            );*/
+            return bundle;
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to fetch remote bundle", error);
         }
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to fetch remote bundle: ${response.statusText}`
-        );
-      }
-      const bundle = await response.json();
-      return bundle;
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to fetch remote bundle",
-        error
-      );
     }
-  }
-  /**
-   * 发送加密消息（支持普通发送和强制发送）
-   */
-  async sendMessage(request) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/message`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(request)
+    /**
+     * 发送加密消息（支持普通发送和强制发送）
+     */
+    async sendMessage(request) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/message`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(request),
+            });
+            const responseData = await response.json();
+            if (!response.ok) {
+                // 错误响应可能包含 guard_list
+                const errorMessage = responseData?.message || response.statusText;
+                const error = new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, errorMessage);
+                // 附加 guard_list 到错误对象（如果存在）
+                error.guardList = responseData?.guard_list;
+                throw error;
+            }
+            return responseData;
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to send message", error);
         }
-      );
-      const responseData = await response.json();
-      if (!response.ok) {
-        const errorMessage = responseData?.message || response.statusText;
-        const error = new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          errorMessage
-        );
-        error.guardList = responseData?.guard_list;
-        throw error;
-      }
-      return responseData;
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to send message",
-        error
-      );
     }
-  }
-  /**
-   * 拉取消息
-   *
-   * 安全要求：必须提供签名验证
-   * @param userAddress 用户地址（用于URL路径）
-   * @param publicKey 用户公钥（用于服务器验签）
-   * @param signatureParams 签名参数
-   */
-  async pullMessages(userAddress, publicKey, signatureParams, limit) {
-    try {
-      const queryParams = new URLSearchParams({
-        publicKey,
-        signatureScheme: signatureParams.signatureScheme,
-        signature: signatureParams.signature,
-        timestamp: signatureParams.timestamp.toString(),
-        nonce: signatureParams.nonce
-      });
-      if (limit !== void 0) {
-        queryParams.set("limit", limit.toString());
-      }
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/messages/${userAddress}?${queryParams}`
-      );
-      if (!response.ok) {
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to pull messages: ${response.statusText}`
-        );
-      }
-      const json = await response.json();
-      return json;
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to pull messages",
-        error
-      );
+    /**
+     * 拉取消息
+     *
+     * 安全要求：必须提供签名验证
+     * @param userAddress 用户地址（用于URL路径）
+     * @param publicKey 用户公钥（用于服务器验签）
+     * @param signatureParams 签名参数
+     */
+    async pullMessages(userAddress, publicKey, signatureParams, limit) {
+        try {
+            const queryParams = new URLSearchParams({
+                publicKey,
+                signatureScheme: signatureParams.signatureScheme,
+                signature: signatureParams.signature,
+                timestamp: signatureParams.timestamp.toString(),
+                nonce: signatureParams.nonce,
+            });
+            if (limit !== undefined) {
+                queryParams.set("limit", limit.toString());
+            }
+            const response = await fetch(`${this.config.serverUrl}/v1/messages/${userAddress}?${queryParams}`);
+            if (!response.ok) {
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to pull messages: ${response.statusText}`);
+            }
+            const json = (await response.json());
+            /*console.log(
+                `[ServerClient] 收到服务器响应: ${json.messages.length} 条消息`,
+            );
+            if (json.messages.length > 0) {
+                console.log(
+                    `[ServerClient] 第一条消息 ID: ${json.messages[0].id}`,
+                );
+            }*/
+            return json;
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to pull messages", error);
+        }
     }
-  }
-  /**
-   * 获取预密钥状态
-   */
-  async getPrekeyStatus(userAddress) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/prekeys/${userAddress}/status`
-      );
-      if (!response.ok) {
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to get prekey status: ${response.statusText}`
-        );
-      }
-      const data = await response.json();
-      return {
-        currentCount: data.current_count,
-        maxAllowed: data.max_allowed,
-        threshold: data.threshold,
-        shouldRefill: data.should_refill
-      };
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to get prekey status",
-        error
-      );
+    /**
+     * 获取预密钥状态
+     */
+    async getPrekeyStatus(userAddress) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/prekeys/${userAddress}/status`);
+            if (!response.ok) {
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to get prekey status: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            return {
+                currentCount: data.current_count,
+                maxAllowed: data.max_allowed,
+                threshold: data.threshold,
+                shouldRefill: data.should_refill,
+            };
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to get prekey status", error);
+        }
     }
-  }
-  /**
-   * 确认消息已处理（从服务器删除）
-   * 接收方验证 plaintextHash 后发送 ARK
-   */
-  async acknowledgeMessages(messageIds, senderPublicKey, signatureParams) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/messages/ack`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            publicKey: signatureParams.publicKey,
-            messageIds,
-            senderPublicKey,
-            signatureScheme: signatureParams.signatureScheme,
-            signature: signatureParams.signature,
-            timestamp: signatureParams.timestamp,
-            nonce: signatureParams.nonce
-          })
+    /**
+     * 确认消息已处理（从服务器删除）
+     * 接收方验证 plaintextHash 后发送 ARK
+     */
+    async acknowledgeMessages(messageIds, senderPublicKey, signatureParams) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/messages/ack`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    publicKey: signatureParams.publicKey,
+                    messageIds,
+                    senderPublicKey,
+                    signatureScheme: signatureParams.signatureScheme,
+                    signature: signatureParams.signature,
+                    timestamp: signatureParams.timestamp,
+                    nonce: signatureParams.nonce,
+                }),
+            });
+            if (!response.ok) {
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to acknowledge messages: ${response.statusText}`);
+            }
         }
-      );
-      if (!response.ok) {
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to acknowledge messages: ${response.statusText}`
-        );
-      }
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to acknowledge messages",
-        error
-      );
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to acknowledge messages", error);
+        }
+    }
+    /**
+     * 黑名单 - 添加地址
+     */
+    async addToBlacklist(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist`, signedRequest, "POST");
+    }
+    /**
+     * 黑名单 - 移除地址
+     */
+    async removeFromBlacklist(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist`, signedRequest, "DELETE");
     }
-  }
-  /**
-   * 黑名单 - 添加地址
-   */
-  async addToBlacklist(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * 黑名单 - 移除地址
-   */
-  async removeFromBlacklist(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist`,
-      signedRequest,
-      "DELETE"
-    );
-  }
-  /**
-   * 黑名单 - 清空
-   */
-  async clearBlacklist(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/clear`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * 黑名单 - 获取列表
-   */
-  async getBlacklist(userAddress, signedRequest) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/get`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(signedRequest)
+    /**
+     * 黑名单 - 清空
+     */
+    async clearBlacklist(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/clear`, signedRequest, "POST");
+    }
+    /**
+     * 黑名单 - 获取列表
+     */
+    async getBlacklist(userAddress, signedRequest) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/get`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(signedRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error("getBlacklist error response:", errorText);
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to get blacklist: ${response.statusText} - ${errorText}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to get blacklist", error);
         }
-      );
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error("getBlacklist error response:", errorText);
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to get blacklist: ${response.statusText} - ${errorText}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to get blacklist",
-        error
-      );
     }
-  }
-  /**
-   * 黑名单 - 检查存在
-   */
-  async existInBlacklist(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/exist`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * 好友列表 - 添加地址
-   */
-  async addToFriendsList(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * 好友列表 - 移除地址
-   */
-  async removeFromFriendsList(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list`,
-      signedRequest,
-      "DELETE"
-    );
-  }
-  /**
-   * 好友列表 - 清空
-   */
-  async clearFriendsList(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/clear`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * 好友列表 - 获取列表
-   */
-  async getFriendsList(userAddress, signedRequest) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/get`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(signedRequest)
+    /**
+     * 黑名单 - 检查存在
+     */
+    async existInBlacklist(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/blacklist/exist`, signedRequest, "POST");
+    }
+    /**
+     * 好友列表 - 添加地址
+     */
+    async addToFriendsList(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list`, signedRequest, "POST");
+    }
+    /**
+     * 好友列表 - 移除地址
+     */
+    async removeFromFriendsList(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list`, signedRequest, "DELETE");
+    }
+    /**
+     * 好友列表 - 清空
+     */
+    async clearFriendsList(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/clear`, signedRequest, "POST");
+    }
+    /**
+     * 好友列表 - 获取列表
+     */
+    async getFriendsList(userAddress, signedRequest) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/get`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(signedRequest),
+            });
+            if (!response.ok) {
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to get friends list: ${response.statusText}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to get friends list", error);
         }
-      );
-      if (!response.ok) {
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to get friends list: ${response.statusText}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to get friends list",
-        error
-      );
     }
-  }
-  /**
-   * 好友列表 - 检查存在
-   */
-  async existInFriendsList(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/exist`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * Guard 列表 - 添加
-   */
-  async addToGuardList(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list`,
-      signedRequest,
-      "POST"
-    );
-  }
-  /**
-   * Guard 列表 - 移除
-   */
-  async removeFromGuardList(userAddress, signedRequest) {
-    return this._listOperation(
-      `${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list`,
-      signedRequest,
-      "DELETE"
-    );
-  }
-  /**
-   * Guard 列表 - 获取列表
-   */
-  async getGuardList(userAddress, signedRequest) {
-    try {
-      const response = await fetch(
-        `${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list/get`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(signedRequest)
+    /**
+     * 好友列表 - 检查存在
+     */
+    async existInFriendsList(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/friends-list/exist`, signedRequest, "POST");
+    }
+    /**
+     * Guard 列表 - 添加
+     */
+    async addToGuardList(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list`, signedRequest, "POST");
+    }
+    /**
+     * Guard 列表 - 移除
+     */
+    async removeFromGuardList(userAddress, signedRequest) {
+        return this._listOperation(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list`, signedRequest, "DELETE");
+    }
+    /**
+     * Guard 列表 - 获取列表
+     */
+    async getGuardList(userAddress, signedRequest) {
+        try {
+            const response = await fetch(`${this.config.serverUrl}/v1/spam-protection/${userAddress}/guard-list/get`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(signedRequest),
+            });
+            if (!response.ok) {
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `Failed to get guard list: ${response.statusText}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to get guard list", error);
         }
-      );
-      if (!response.ok) {
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `Failed to get guard list: ${response.statusText}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to get guard list",
-        error
-      );
     }
-  }
-  /**
-   * 内部方法：列表操作
-   */
-  async _listOperation(url, signedRequest, method = "POST") {
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(signedRequest)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new import_types.MessengerError(
-          import_types.MessengerErrorCode.SERVER_ERROR,
-          `List operation failed: ${response.statusText} - ${errorText}`
-        );
-      }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof import_types.MessengerError) throw error;
-      throw new import_types.MessengerError(
-        import_types.MessengerErrorCode.NETWORK_ERROR,
-        "Failed to perform list operation",
-        error
-      );
+    /**
+     * 内部方法：列表操作
+     */
+    async _listOperation(url, signedRequest, method = "POST") {
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(signedRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.SERVER_ERROR, `List operation failed: ${response.statusText} - ${errorText}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof types_js_1.MessengerError)
+                throw error;
+            throw new types_js_1.MessengerError(types_js_1.MessengerErrorCode.NETWORK_ERROR, "Failed to perform list operation", error);
+        }
     }
-  }
 }
-const defaultServerClient = new MessengerServerClient();
+exports.MessengerServerClient = MessengerServerClient;
+// 导出单例
+exports.defaultServerClient = new MessengerServerClient();
+//# sourceMappingURL=server.js.map