wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,428 @@
+import { ed25519, x25519 } from "@noble/curves/ed25519";
+import { sha256 } from "@noble/hashes/sha256";
+import { randomBytes } from "@noble/hashes/utils";
+function verifyEd25519(publicKey, message, signature) {
+  try {
+    return ed25519.verify(signature, message, publicKey);
+  } catch {
+    return false;
+  }
+}
+function recoverXed25519FromX25519PrivateKey(x25519PrivateKey) {
+  const x25519PublicKey = x25519.getPublicKey(x25519PrivateKey);
+  const ed25519PrivateKey = x25519PrivateKey;
+  const ed25519PublicKey = ed25519.getPublicKey(ed25519PrivateKey);
+  return {
+    x25519PublicKey,
+    x25519PrivateKey,
+    ed25519PrivateKey,
+    ed25519PublicKey
+  };
+}
+function hashSha256(data) {
+  return sha256(data);
+}
+function hashMessage(data) {
+  const hash = sha256(new TextEncoder().encode(data));
+  return bytesToHex(hash);
+}
+function hashPlaintext(plaintext, clientTimestamp, guardAddress, passportAddress, lastReceivedLeafIndex) {
+  let data = plaintext + clientTimestamp.toString();
+  if (lastReceivedLeafIndex !== void 0 && lastReceivedLeafIndex >= 0) {
+    data += lastReceivedLeafIndex.toString();
+  }
+  if (guardAddress) {
+    data += guardAddress;
+  }
+  if (passportAddress) {
+    data += passportAddress;
+  }
+  const hash = sha256(new TextEncoder().encode(data));
+  return "0x" + bytesToHex(hash);
+}
+function generateNonce() {
+  return bytesToHex(randomBytes(16));
+}
+function bytesToBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function base64ToBytes(base64) {
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function bytesToHex(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function hexToBytes(hex) {
+  return new Uint8Array(Buffer.from(hex, "hex"));
+}
+function arrayBufferToUint8Array(buf) {
+  return new Uint8Array(buf);
+}
+function uint8ArrayToArrayBuffer(arr) {
+  const result = arr.buffer.slice(
+    arr.byteOffset,
+    arr.byteOffset + arr.byteLength
+  );
+  return result;
+}
+function bufferEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  const va = new Uint8Array(a);
+  const vb = new Uint8Array(b);
+  for (let i = 0; i < va.length; i++) {
+    if (va[i] !== vb[i]) return false;
+  }
+  return true;
+}
+function calculateMerkleLeafHash(plaintextHash, serverTimestamp) {
+  const plaintextHashBytes = new TextEncoder().encode(plaintextHash);
+  const timestampBuffer = new ArrayBuffer(8);
+  const timestampView = new DataView(timestampBuffer);
+  timestampView.setBigUint64(0, BigInt(serverTimestamp), true);
+  const timestampBytes = new Uint8Array(timestampBuffer);
+  const combined = new Uint8Array(
+    plaintextHashBytes.length + timestampBytes.length
+  );
+  combined.set(plaintextHashBytes);
+  combined.set(timestampBytes, plaintextHashBytes.length);
+  const hash = sha256(combined);
+  return "0x" + bytesToHex(hash);
+}
+function merkleHash(left, right) {
+  const leftBytes = hexToBytes(left.replace(/^0x/, ""));
+  const rightBytes = hexToBytes(right.replace(/^0x/, ""));
+  const combined = new Uint8Array(leftBytes.length + rightBytes.length);
+  combined.set(leftBytes);
+  combined.set(rightBytes, leftBytes.length);
+  return "0x" + bytesToHex(sha256(combined));
+}
+function computeNewRoot(prevRoot, leafHash, leafIndex) {
+  const prevRootBytes = new TextEncoder().encode(prevRoot);
+  const leafHashBytes = new TextEncoder().encode(leafHash);
+  const leafIndexBuffer = new ArrayBuffer(4);
+  const leafIndexView = new DataView(leafIndexBuffer);
+  leafIndexView.setUint32(0, leafIndex, true);
+  const leafIndexBytes = new Uint8Array(leafIndexBuffer);
+  const combined = new Uint8Array(
+    prevRootBytes.length + leafHashBytes.length + leafIndexBytes.length
+  );
+  combined.set(prevRootBytes);
+  combined.set(leafHashBytes, prevRootBytes.length);
+  combined.set(leafIndexBytes, prevRootBytes.length + leafHashBytes.length);
+  return "0x" + bytesToHex(sha256(combined));
+}
+function verifyMerkleProof(leafHash, proof) {
+  let current = leafHash;
+  for (let i = 0; i < proof.siblings.length; i++) {
+    if (proof.indices[i] === 0) {
+      current = merkleHash(current, proof.siblings[i]);
+    } else {
+      current = merkleHash(proof.siblings[i], current);
+    }
+  }
+  return current === proof.root;
+}
+function verifyMerkleChain(messages, initialRoot) {
+  if (messages.length === 0) {
+    return { valid: true };
+  }
+  const sortedMessages = [...messages].sort(
+    (a, b) => a.leafIndex - b.leafIndex
+  );
+  const zeroRoot = initialRoot || "0x" + "0".repeat(64);
+  let expectedPrevRoot = zeroRoot;
+  for (const msg of sortedMessages) {
+    if (msg.prevRoot.toLowerCase() !== expectedPrevRoot.toLowerCase()) {
+      return {
+        valid: false,
+        error: `Root chain broken at leafIndex ${msg.leafIndex}: expected prevRoot ${expectedPrevRoot}, got ${msg.prevRoot}`,
+        expectedRoot: expectedPrevRoot,
+        actualRoot: msg.prevRoot
+      };
+    }
+    const result = verifySingleMerkleRoot(
+      msg.prevRoot,
+      msg.newRoot,
+      msg.plaintextHash,
+      msg.serverTimestamp,
+      msg.leafIndex
+    );
+    if (!result.valid) {
+      return {
+        valid: false,
+        error: `${result.error} at leafIndex ${msg.leafIndex}`,
+        expectedRoot: result.expectedRoot,
+        actualRoot: result.actualRoot
+      };
+    }
+    expectedPrevRoot = msg.newRoot;
+  }
+  return { valid: true };
+}
+function verifySingleMerkleRoot(prevRoot, newRoot, plaintextHash, serverTimestamp, leafIndex) {
+  const leafHash = calculateMerkleLeafHash(plaintextHash, serverTimestamp);
+  const computedRoot = computeNewRoot(prevRoot, leafHash, leafIndex);
+  if (computedRoot.toLowerCase() !== newRoot.toLowerCase()) {
+    return {
+      valid: false,
+      error: `Root computation mismatch: expected ${computedRoot}, got ${newRoot}`,
+      expectedRoot: computedRoot,
+      actualRoot: newRoot
+    };
+  }
+  return { valid: true };
+}
+function verifyMessage(params) {
+  const {
+    messageId,
+    plaintext,
+    plaintextHash,
+    createdAt,
+    guardAddress,
+    passportAddress,
+    lastReceivedLeafIndex,
+    serverSignature,
+    serverPublicKey,
+    merkleMetadata
+  } = params;
+  const computedPlaintextHash = hashPlaintext(
+    plaintext,
+    createdAt,
+    guardAddress,
+    passportAddress,
+    lastReceivedLeafIndex
+  );
+  const normalizeHash = (hash) => {
+    return hash.toLowerCase().replace(/^0x/, "");
+  };
+  if (normalizeHash(computedPlaintextHash) !== normalizeHash(plaintextHash)) {
+    return {
+      valid: false,
+      error: `Plaintext hash mismatch for message ${messageId}: expected ${plaintextHash}, got ${computedPlaintextHash}`,
+      failedCheck: "plaintext"
+    };
+  }
+  if (merkleMetadata) {
+    if (merkleMetadata.proofSiblings && merkleMetadata.proofIndices) {
+      const bodyB64 = bytesToBase64(new TextEncoder().encode(plaintext));
+      const leafHash = hashMessage(bodyB64);
+      const proofValid = verifyMerkleProof(leafHash, {
+        root: merkleMetadata.newRoot,
+        siblings: merkleMetadata.proofSiblings,
+        indices: merkleMetadata.proofIndices
+      });
+      if (!proofValid) {
+        return {
+          valid: false,
+          error: `Merkle proof verification failed for message ${messageId}`,
+          failedCheck: "merkle"
+        };
+      }
+    }
+    const serverTimestamp = merkleMetadata.serverTimestamp;
+    if (!serverTimestamp) {
+      return {
+        valid: false,
+        error: `Missing server timestamp for Merkle root verification in message ${messageId}`,
+        failedCheck: "merkle"
+      };
+    }
+    if (!merkleMetadata.prevRoot) {
+      return {
+        valid: false,
+        error: `Missing prevRoot for Merkle root verification in message ${messageId}`,
+        failedCheck: "merkle"
+      };
+    }
+    const rootValid = verifySingleMerkleRoot(
+      merkleMetadata.prevRoot,
+      merkleMetadata.newRoot,
+      plaintextHash,
+      serverTimestamp,
+      merkleMetadata.leafIndex
+    );
+    if (!rootValid.valid) {
+      return {
+        valid: false,
+        error: `Merkle root verification failed for message ${messageId}: ${rootValid.error}`,
+        failedCheck: "merkle"
+      };
+    }
+  }
+  if (serverSignature && serverPublicKey) {
+    const timestamp = merkleMetadata?.serverTimestamp;
+    if (!timestamp) {
+      return {
+        valid: false,
+        error: `Missing server timestamp for signature verification in message ${messageId}`,
+        failedCheck: "merkle"
+      };
+    }
+    if (!merkleMetadata?.newRoot) {
+      return {
+        valid: false,
+        error: `Missing newRoot for signature verification in message ${messageId}`,
+        failedCheck: "merkle"
+      };
+    }
+    if (!merkleMetadata?.prevRoot) {
+      return {
+        valid: false,
+        error: `Missing prevRoot for signature verification in message ${messageId}`,
+        failedCheck: "merkle"
+      };
+    }
+    const signData = `${merkleMetadata.prevRoot}:${merkleMetadata.newRoot}:${timestamp}:${serverPublicKey}`;
+    const signatureValid = verifyEd25519Signature(
+      serverPublicKey,
+      signData,
+      serverSignature
+    );
+    if (!signatureValid) {
+      return {
+        valid: false,
+        error: `Server signature verification failed for message ${messageId}`,
+        failedCheck: "merkle"
+      };
+    }
+  }
+  return { valid: true };
+}
+function verifyEd25519Signature(publicKeyHex, message, signatureHex) {
+  try {
+    const publicKey = hexToBytes(publicKeyHex.replace("0x", ""));
+    const signature = hexToBytes(signatureHex.replace("0x", ""));
+    const messageBytes = new TextEncoder().encode(message);
+    return verifyEd25519(publicKey, messageBytes, signature);
+  } catch {
+    return false;
+  }
+}
+function verifyWtsMessages(messages) {
+  if (messages.length === 0) {
+    return { valid: true };
+  }
+  const sortedMessages = [...messages].sort(
+    (a, b) => a.leafIndex - b.leafIndex
+  );
+  for (let i = 0; i < sortedMessages.length; i++) {
+    const msg = sortedMessages[i];
+    if (msg.plaintext != null) {
+      const computedHash = hashPlaintext(
+        msg.plaintext || "",
+        msg.clientTimestamp,
+        msg.guardAddress,
+        msg.passportAddress,
+        msg.lastReceivedLeafIndex
+      );
+      if (computedHash.toLowerCase() !== msg.plaintextHash.toLowerCase()) {
+        return {
+          valid: false,
+          error: `Plaintext hash mismatch for message ${msg.id} at index ${i}`,
+          failedMessageIndex: i,
+          failedCheck: "plaintext"
+        };
+      }
+    }
+    if (msg.merkleProof) {
+      const bodyB64 = bytesToBase64(
+        new TextEncoder().encode(msg.plaintext || "")
+      );
+      const leafHash = hashMessage(bodyB64);
+      const proofValid = verifyMerkleProof(leafHash, {
+        root: msg.merkleRoot,
+        siblings: msg.merkleProof.siblings,
+        indices: msg.merkleProof.indices
+      });
+      if (!proofValid) {
+        return {
+          valid: false,
+          error: `Merkle proof verification failed for message ${msg.id} at index ${i}`,
+          failedMessageIndex: i,
+          failedCheck: "merkle"
+        };
+      }
+    }
+    if (msg.serverSignature && msg.serverPublicKey) {
+      if (!msg.merkleRoot) {
+        return {
+          valid: false,
+          error: `Missing merkleRoot for message ${msg.id} at index ${i}`,
+          failedMessageIndex: i,
+          failedCheck: "merkle"
+        };
+      }
+      if (!msg.timestamp) {
+        return {
+          valid: false,
+          error: `Missing timestamp for message ${msg.id} at index ${i}`,
+          failedMessageIndex: i,
+          failedCheck: "merkle"
+        };
+      }
+      if (!msg.prevRoot) {
+        return {
+          valid: false,
+          error: `Missing prevRoot for message ${msg.id} at index ${i}`,
+          failedMessageIndex: i,
+          failedCheck: "merkle"
+        };
+      }
+      const signData = `${msg.prevRoot}:${msg.merkleRoot}:${msg.timestamp}:${msg.serverPublicKey}`;
+      const signatureValid = verifyEd25519Signature(
+        msg.serverPublicKey,
+        signData,
+        msg.serverSignature
+      );
+      if (!signatureValid) {
+        return {
+          valid: false,
+          error: `Server signature verification failed for message ${msg.id} at index ${i}`,
+          failedMessageIndex: i,
+          failedCheck: "merkle"
+        };
+      }
+    }
+  }
+  const chainResult = verifyMerkleChain(
+    sortedMessages.map((msg) => ({
+      leafIndex: msg.leafIndex,
+      prevRoot: msg.merkleRoot,
+      // WTS 中只保存了最终的 merkleRoot
+      newRoot: msg.merkleRoot,
+      plaintextHash: msg.plaintextHash,
+      serverTimestamp: msg.timestamp
+    }))
+  );
+  if (!chainResult.valid) {
+    return {
+      valid: false,
+      error: chainResult.error,
+      failedCheck: "chain"
+    };
+  }
+  return { valid: true };
+}
+export {
+  arrayBufferToUint8Array,
+  base64ToBytes,
+  bufferEqual,
+  bytesToBase64,
+  bytesToHex,
+  calculateMerkleLeafHash,
+  computeNewRoot,
+  generateNonce,
+  hashMessage,
+  hashPlaintext,
+  hashSha256,
+  hexToBytes,
+  merkleHash,
+  recoverXed25519FromX25519PrivateKey,
+  uint8ArrayToArrayBuffer,
+  verifyEd25519Signature,
+  verifyMerkleChain,
+  verifyMerkleProof,
+  verifyMessage,
+  verifySingleMerkleRoot,
+  verifyWtsMessages
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Wowok Messenger SDK
+ *
+ * 基于三重信任模型的端到端加密消息系统：
+ *
+ * 1. 身份信任（Identity Trust）
+ *    - 基于 wowok 账户体系的 Ed25519 签名
+ *    - 每个用户的钱包地址即身份标识
+ *
+ * 2. 加密信任（Encryption Trust）
+ *    - 基于 Signal Protocol 的双棘轮算法
+ *    - 端到端加密，服务器无法解密
+ *
+ * 3. 时序信任（Temporal Trust）
+ *    - 基于 Merkle Tree 的消息时序完整性
+ *    - 服务器签名确保消息顺序
+ *    - 链上证明提供不可篡改的时间戳
+ */
+export { MessengerManager } from "./messenger-manager.js";
+export { Messenger } from "./messenger.js";
+export * from "./messenger-api.js";
+export type { Message, MessageFilter, SendMessageResult, DecryptedMessage, MessengerConfig, MessageListResult, ConversationInfo, WtsGenerationParams, WtsFileResult, MessageContentType, } from "./types.js";
+export { MessageType, MessageDirection, MessageStatus, MessengerErrorCode, DEFAULT_MESSENGER_CONFIG, MessengerError, DEFAULT_QUERY_LIMIT, MAX_QUERY_LIMIT, } from "./types.js";

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

@@ -0,0 +1,25 @@
+import { MessengerManager } from "./messenger-manager.js";
+import { Messenger } from "./messenger.js";
+export * from "./messenger-api.js";
+import {
+  MessageType,
+  MessageDirection,
+  MessageStatus,
+  MessengerErrorCode,
+  DEFAULT_MESSENGER_CONFIG,
+  MessengerError,
+  DEFAULT_QUERY_LIMIT,
+  MAX_QUERY_LIMIT
+} from "./types.js";
+export {
+  DEFAULT_MESSENGER_CONFIG,
+  DEFAULT_QUERY_LIMIT,
+  MAX_QUERY_LIMIT,
+  MessageDirection,
+  MessageStatus,
+  MessageType,
+  Messenger,
+  MessengerError,
+  MessengerErrorCode,
+  MessengerManager
+};

package/dist/esm/w/messenger/messenger-api.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Messenger API
+ *
+ * 提供简单的接口用于管理 inbox 账号和发送消息
+ */
+import type { ConversationInfo, Message, MessageFilter, SendMessageResult, WtsFileResult, WtsGenerationParams, WtsToHtmlOptions, WtsVerificationResult, ListOperationResponse } from "./types.js";
+import { MessengerManager } from "./messenger-manager.js";
+import type { ENTRYPOINT } from "../../client/network.js";
+import type { AccountOrMark_Address, ManyAccountOrMark_Address } from "../local/index.js";
+/**
+ * 获取 MessengerManager 实例（单例）
+ * 首次调用时会自动启动后台服务
+ */
+export declare function getMessengerManager(): MessengerManager;
+export declare function watch_conversations(account?: string | undefined | null): Promise<ConversationInfo[]>;
+/**
+ * 发送消息
+ *
+ * @param from 发送者地址
+ * @param to 接收者地址
+ * @param content 消息内容
+ * @param options 可选配置
+ * @returns SendMessageResult
+ */
+export declare function send_message(from: string | undefined | null, to: AccountOrMark_Address, content: string, options?: {
+    guardAddress?: string;
+    passportAddress?: string;
+    force?: boolean;
+    new_messenger_name?: string;
+}): Promise<SendMessageResult>;
+/**
+ * 发送文件（ZIP 格式）
+ *
+ * 支持发送本地文件，经过 ZIP 压缩后发送给对方
+ * 支持 Guard 验证，如果提供 guardAddress 和 passportAddress，消息将进入 Guard 验证流程
+ *
+ * @param from 发送者账号或地址
+ * @param to 接收者地址
+ * @param filePath 本地文件路径
+ * @param options 可选配置
+ * @returns SendMessageResult
+ */
+export declare function send_file(from: string | undefined | null, to: AccountOrMark_Address, filePath: string, options?: {
+    fileName?: string;
+    contentType?: "wts" | "wip" | "zip";
+    guardAddress?: string;
+    passportAddress?: string;
+    force?: boolean;
+    new_messenger_name?: string;
+}): Promise<SendMessageResult>;
+/**
+ * 查询消息
+ *
+ * @param filter 过滤条件
+ * @returns Message 数组
+ */
+export declare function watch_messages(filter?: MessageFilter & {
+    account?: string;
+}): Promise<Message[]>;
+/**
+ * 批量解压多个 ZIP 消息到指定目录
+ *
+ * @param messages 包含 ZIP 数据的消息数组，或消息 ID 数组
+ * @param outputDir 输出目录路径
+ * @param userAddress 用户地址（当传入消息ID数组时需要）
+ * @returns 解压后的文件路径数组
+ */
+export declare function extract_zip_messages(account: string | undefined | null, messages: (Message | string)[], outputDir: string): Promise<string[]>;
+export declare function generate_wts(params: WtsGenerationParams): Promise<WtsFileResult>;
+/**
+ * 验证 WTS 文件
+ *
+ * 验证内容包括：
+ * 1. 文件结构完整性
+ * 2. Merkle 链连续性
+ * 3. 消息哈希格式
+ * 4. Payload 哈希匹配
+ * 5. 数字签名（如果存在）
+ *
+ * @param wtsFilePath WTS 文件路径（本地或网络文件）
+ * @returns 验证结果
+ */
+export declare function verify_wts(wtsFilePath: string): Promise<WtsVerificationResult>;
+/**
+ * 使用账号签名 WTS 文件
+ *
+ * 此函数会自动加载 WTS 文件、验证格式、签名并保存。
+ *
+ * @param wtsFilePath WTS 文件路径（本地或网络文件）
+ * @param account 签名账号
+ * @param outputPath 输出文件路径（可选，默认覆盖原文件）
+ * @returns 签名后的 WTS 文件路径
+ */
+export declare function sign_wts(wtsFilePath: string, account: string | undefined | null, outputPath?: string): Promise<string>;
+/**
+ * 将 WTS 文件或文件夹转换为 HTML
+ *
+ * @param wtsPath WTS 文件路径或文件夹路径（本地或网络文件）
+ * @param options 转换选项
+ * @returns HTML 字符串、保存的文件路径，或转换的文件路径数组
+ */
+export declare function wts2html(wtsPath: string, options: WtsToHtmlOptions & {
+    outputPath: string;
+}): Promise<string>;
+export declare function wts2html(wtsPath: string, options?: WtsToHtmlOptions): Promise<string | string[]>;
+/**
+ * 提交消息链上证明
+ *
+ * 将消息的 Merkle 证明提交到链上，创建不可篡改的证明记录。
+ * 此函数会先验证消息的完整性和合法性。
+ *
+ * @param account 账号名称或地址
+ * @param messageId 消息ID
+ * @param env 调用环境（包含网络、签名账号等）
+ * @returns 证明对象地址
+ */
+export declare function proof_message(account: string | undefined | null, messageId: string, network: ENTRYPOINT): Promise<{
+    proofAddress: string;
+}>;
+export type BlacklistRequest = {
+    op: "add" | "remove";
+    account: string | undefined | null;
+    users: ManyAccountOrMark_Address;
+} | {
+    op: "clear";
+    account: string | undefined | null;
+} | {
+    op: "get";
+    account: string | undefined | null;
+} | {
+    op: "exist";
+    account: string | undefined | null;
+    users: ManyAccountOrMark_Address;
+};
+export type BlacklistResponse = {
+    op: "add";
+    result: ListOperationResponse;
+} | {
+    op: "remove";
+    result: ListOperationResponse;
+} | {
+    op: "clear";
+    result: ListOperationResponse;
+} | {
+    op: "get";
+    result: string[];
+} | {
+    op: "exist";
+    result: ListOperationResponse;
+};
+/**
+ * 黑名单管理 - 统一入口
+ * @param request 操作请求
+ * @returns 操作结果
+ */
+export declare function blacklist(request: BlacklistRequest): Promise<BlacklistResponse>;
+export type FriendslistRequest = {
+    op: "add" | "remove";
+    account: string | undefined | null;
+    users: ManyAccountOrMark_Address;
+} | {
+    op: "clear";
+    account: string | undefined | null;
+} | {
+    op: "get";
+    account: string | undefined | null;
+} | {
+    op: "exist";
+    account: string | undefined | null;
+    users: ManyAccountOrMark_Address;
+};
+export type FriendslistResponse = {
+    op: "add";
+    result: ListOperationResponse;
+} | {
+    op: "remove";
+    result: ListOperationResponse;
+} | {
+    op: "clear";
+    result: ListOperationResponse;
+} | {
+    op: "get";
+    result: string[];
+} | {
+    op: "exist";
+    result: ListOperationResponse;
+};
+/**
+ * 好友列表管理 - 统一入口
+ * @param request 操作请求
+ * @returns 操作结果
+ */
+export declare function friendslist(request: FriendslistRequest): Promise<FriendslistResponse>;
+export interface GuardParam {
+    guard: string;
+    passportValiditySeconds: number;
+}
+export type GuardlistRequest = {
+    op: "add";
+    account: string | undefined | null;
+    guards: GuardParam[];
+} | {
+    op: "remove";
+    account: string | undefined | null;
+    guards: string[];
+} | {
+    op: "get";
+    account: string | undefined | null;
+};
+export type GuardlistResponse = {
+    op: "add";
+    result: ListOperationResponse;
+} | {
+    op: "remove";
+    result: ListOperationResponse;
+} | {
+    op: "get";
+    result: ListOperationResponse;
+};
+/**
+ * Guard 列表管理 - 统一入口
+ * @param request 操作请求
+ * @returns 操作结果
+ */
+export declare function guardlist(request: GuardlistRequest): Promise<GuardlistResponse>;