wowok 1.8.3 → 2.1.10

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

@@ -0,0 +1,1247 @@
+"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 __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 messenger_api_exports = {};
+__export(messenger_api_exports, {
+  blacklist: () => blacklist,
+  extract_zip_messages: () => extract_zip_messages,
+  friendslist: () => friendslist,
+  generate_wts: () => generate_wts,
+  getMessengerManager: () => getMessengerManager,
+  guardlist: () => guardlist,
+  proof_message: () => proof_message,
+  send_file: () => send_file,
+  send_message: () => send_message,
+  sign_wts: () => sign_wts,
+  verify_wts: () => verify_wts,
+  watch_conversations: () => watch_conversations,
+  watch_messages: () => watch_messages,
+  wts2html: () => wts2html
+});
+module.exports = __toCommonJS(messenger_api_exports);
+var import_messenger_manager = require("./messenger-manager.js");
+var import_account = require("../local/account.js");
+var import_exception = require("../exception.js");
+var import_sui_types = require("../../utils/sui-types.js");
+var import_local = require("../local/local.js");
+var import_storage = require("./storage.js");
+var import_types = require("./types.js");
+var import_crypto = require("crypto");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_common = require("../common.js");
+var import_crypto2 = require("./crypto.js");
+var import_utils = require("./utils.js");
+var import_local2 = require("../local/index.js");
+var import_object = require("../query/object.js");
+var import_messenger = require("./messenger.js");
+let managerInstance = null;
+let isInitialized = false;
+let backgroundTimer = null;
+async function autoRegisterMessengerAccounts() {
+  const accounts = await import_account.Account.Instance().list_messenger_accounts();
+  for (const account of accounts) {
+    if (!account.address || !account.m) {
+      continue;
+    }
+    const messenger = new import_messenger.Messenger(account.address);
+    await messenger.initialize();
+  }
+}
+function getMessengerManager() {
+  if (!managerInstance) {
+    managerInstance = new import_messenger_manager.MessengerManager();
+  }
+  if (!isInitialized) {
+    isInitialized = true;
+    autoRegisterMessengerAccounts().catch((err) => {
+      console.error("Failed to auto-register messenger accounts:", err);
+    });
+    managerInstance.start().catch((err) => {
+      console.error("Failed to auto-start messenger manager:", err);
+    });
+  }
+  return managerInstance;
+}
+async function backgroundCheck() {
+  try {
+    const manager = getMessengerManager();
+    await manager.start();
+  } catch (err) {
+    console.error("Background check failed:", err);
+  }
+  await autoRegisterMessengerAccounts();
+}
+function startBackgroundTimer() {
+  if (backgroundTimer) {
+    clearInterval(backgroundTimer);
+  }
+  backgroundTimer = setInterval(() => {
+    backgroundCheck().catch(() => {
+    });
+  }, 60 * 1e3);
+  backgroundCheck().catch(() => {
+  });
+}
+function registerCleanupHandler() {
+  const cleanup = () => {
+    if (backgroundTimer) {
+      clearInterval(backgroundTimer);
+      backgroundTimer = null;
+    }
+    if (managerInstance) {
+      managerInstance.stop();
+    }
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit();
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit();
+  });
+}
+registerCleanupHandler();
+startBackgroundTimer();
+async function watch_conversations(account) {
+  const address = await import_account.Account.Instance().get_address(account);
+  if (!address) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `watch_conversations.account ${account}`
+    );
+  }
+  const manager = getMessengerManager();
+  return manager.get_conversations(address);
+}
+async function send_message(from, to, content, options) {
+  const fromAddress = await import_account.Account.Instance().get_address(from);
+  if (!fromAddress) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.AccountNotFound, `send_message.from ${from}`);
+  }
+  const t = await (0, import_local2.GetAccountOrMark_Address)(to);
+  if (!t) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `send_message.to ${to} is not a valid account/address`
+    );
+  }
+  if (options?.guardAddress != null && options?.passportAddress != null) {
+    [options.guardAddress, options.passportAddress] = await import_local.LocalMark.Instance().get_many_address([
+      options.guardAddress,
+      options.passportAddress
+    ]);
+    if (!options.guardAddress || !options.passportAddress) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.AccountNotFound,
+        `send_message.guardAddress or passportAddress not found`
+      );
+    }
+  }
+  const manager = getMessengerManager();
+  return manager.send(fromAddress, t, content, options);
+}
+async function send_file(from, to, filePath, options) {
+  const fromAddress = await import_account.Account.Instance().get_address(from);
+  if (!fromAddress) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.AccountNotFound, `send_file.from ${from}`);
+  }
+  const t = await (0, import_local2.GetAccountOrMark_Address)(to);
+  if (!t) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `send_file.to ${to} is not a valid account/address`
+    );
+  }
+  if (options?.guardAddress != null && options?.passportAddress != null) {
+    [options.guardAddress, options.passportAddress] = await import_local.LocalMark.Instance().get_many_address([
+      options.guardAddress,
+      options.passportAddress
+    ]);
+    if (!options.guardAddress || !options.passportAddress) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.AccountNotFound,
+        `send_file.guardAddress or passportAddress not found`
+      );
+    }
+  }
+  const manager = getMessengerManager();
+  return manager.send_file(fromAddress, t, filePath, options);
+}
+async function watch_messages(filter) {
+  if (filter?.account) {
+    filter.account = await import_account.Account.Instance().get_address(filter.account);
+  }
+  if (filter?.customListFilter?.includeAddresses != null) {
+    filter.customListFilter.includeAddresses = (await import_account.Account.Instance().get_many_address(
+      filter.customListFilter.includeAddresses
+    )).filter((v) => v != null);
+  }
+  if (filter?.customListFilter?.excludeAddresses != null) {
+    filter.customListFilter.excludeAddresses = (await import_account.Account.Instance().get_many_address(
+      filter.customListFilter.excludeAddresses
+    )).filter((v) => v != null);
+  }
+  const manager = getMessengerManager();
+  return manager.watch(filter);
+}
+async function extract_zip_message(message, outputDir) {
+  if (!message.zipMetadata) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_MESSAGE_TYPE,
+      "Message is not a ZIP archive"
+    );
+  }
+  if (!message.plaintext) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.MESSAGE_NOT_DECRYPTED,
+      "Message plaintext not available"
+    );
+  }
+  const zipBase64 = message.plaintext;
+  const zipData = Buffer.from(zipBase64, "base64");
+  if (message.zipMetadata?.fileHash) {
+    const actualHash = (0, import_crypto.createHash)("sha256").update(zipData).digest("hex");
+    const expectedHash = message.zipMetadata.fileHash.replace("0x", "");
+    if (actualHash !== expectedHash) {
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.HASH_MISMATCH,
+        `ZIP file hash mismatch: expected ${expectedHash}, got ${actualHash}`
+      );
+    }
+  }
+  const JSZip = (await import("jszip")).default;
+  const zip = await JSZip.loadAsync(zipData);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  const savedPaths = [];
+  for (const [fileName, file] of Object.entries(zip.files)) {
+    const zipFile = file;
+    if (!zipFile.dir) {
+      const content = await zipFile.async("nodebuffer");
+      const outputPath = path.join(outputDir, fileName);
+      fs.writeFileSync(outputPath, content);
+      savedPaths.push(outputPath);
+    }
+  }
+  if (savedPaths.length > 0 && message.zipMetadata) {
+    const updatedMetadata = {
+      fileName: message.zipMetadata.fileName,
+      fileSize: message.zipMetadata.fileSize,
+      fileHash: message.zipMetadata.fileHash,
+      contentType: message.zipMetadata.contentType,
+      localCachePath: savedPaths[0],
+      downloadedAt: Date.now()
+    };
+    message.zipMetadata = updatedMetadata;
+    const userAddress = message.direction === "sent" ? message.fromAddress : message.toAddress;
+    const messageStorage = new import_storage.MessageStorage(userAddress);
+    messageStorage.saveMessage(message);
+  }
+  return savedPaths[0] || "";
+}
+async function extract_zip_messages(account, messages, outputDir) {
+  const results = [];
+  const userAddress = await import_account.Account.Instance().get_address(account);
+  if (!userAddress) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_INPUT,
+      "account is required when extracting by message IDs"
+    );
+  }
+  const isMessageIds = messages.length > 0 && typeof messages[0] === "string";
+  for (const item of messages) {
+    try {
+      let message;
+      if (isMessageIds) {
+        const messageId = item;
+        const messageStorage = new import_storage.MessageStorage(userAddress);
+        const storedMessage = messageStorage.getMessageById(messageId);
+        if (!storedMessage) {
+          console.error(`Message not found: ${messageId}`);
+          continue;
+        }
+        message = storedMessage;
+      } else {
+        message = item;
+      }
+      if (!message.zipMetadata) {
+        console.error(
+          `Message ${message.messageId} is not a ZIP archive`
+        );
+        continue;
+      }
+      const filePath = await extract_zip_message(message, outputDir);
+      results.push(filePath);
+    } catch (e) {
+      const id = isMessageIds ? item : item.messageId;
+      console.error(`Failed to extract message ${id}:`, e);
+    }
+  }
+  return results;
+}
+async function generate_wts(params) {
+  const myAddress = await import_account.Account.Instance().get_address(params.myAccount);
+  if (!myAddress) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `generate_wts.myAccount ${params.myAccount}`
+    );
+  }
+  if (!(0, import_sui_types.isValidWowAddress)(params.peerAccount)) {
+    const t = await import_account.Account.Instance().get_address(params.peerAccount);
+    if (!t) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.AccountNotFound,
+        `generate_wts.peerAccount ${params.peerAccount}`
+      );
+    }
+    params.peerAccount = t;
+  }
+  return getMessengerManager().generate_wts(params);
+}
+function load_wts(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function save_wts(wtsFile, filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(wtsFile, null, 2), "utf-8");
+}
+async function verify_wts(wtsFilePath) {
+  try {
+    const wtsFile = load_wts(wtsFilePath);
+    if (!wtsFile.wts || !wtsFile.payload || !wtsFile.meta) {
+      return { valid: false, error: "Invalid WTS file structure" };
+    }
+    if (wtsFile.meta.type !== "wts") {
+      return {
+        valid: false,
+        error: `Invalid meta.type: ${wtsFile.meta.type}`
+      };
+    }
+    const { payload, meta } = wtsFile;
+    for (const msg of payload.messages) {
+      const result = (0, import_crypto2.verifySingleMerkleRoot)(
+        msg.prevRoot,
+        msg.merkleRoot,
+        msg.plaintextHash,
+        msg.timestamp,
+        msg.leafIndex
+      );
+      if (!result.valid) {
+        return {
+          valid: false,
+          error: `${result.error} at leafIndex ${msg.leafIndex}`
+        };
+      }
+    }
+    for (let i = 0; i < payload.messages.length; i++) {
+      const msg = payload.messages[i];
+      const isNonTextMsg = !!msg.zipMetadata;
+      if (!isNonTextMsg) {
+        if (!msg.plaintextHash.startsWith("0x") || msg.plaintextHash.length !== 66) {
+          return {
+            valid: false,
+            error: `Message ${i}: Invalid plaintextHash format`
+          };
+        }
+        if (msg.plaintext) {
+          const computedHash2 = (0, import_crypto2.hashPlaintext)(
+            msg.plaintext,
+            msg.clientTimestamp,
+            msg.guardAddress,
+            msg.passportAddress,
+            msg.lastReceivedLeafIndex
+          );
+          if (computedHash2.toLowerCase() !== msg.plaintextHash.toLowerCase()) {
+            return {
+              valid: false,
+              error: `Message ${i}: Plaintext hash mismatch`
+            };
+          }
+        }
+      }
+      if (msg.serverSignature && msg.serverPublicKey) {
+        if (!msg.timestamp) {
+          return {
+            valid: false,
+            error: `Message ${i}: Missing timestamp for signature verification`
+          };
+        }
+        if (!msg.merkleRoot) {
+          return {
+            valid: false,
+            error: `Message ${i}: Missing merkleRoot for signature verification`
+          };
+        }
+        if (!msg.prevRoot) {
+          return {
+            valid: false,
+            error: `Message ${i}: Missing prevRoot for signature verification`
+          };
+        }
+        const signData = `${msg.prevRoot}:${msg.merkleRoot}:${msg.timestamp}:${msg.serverPublicKey}`;
+        const signatureValid2 = (0, import_crypto2.verifyEd25519Signature)(
+          msg.serverPublicKey,
+          signData,
+          msg.serverSignature
+        );
+        if (!signatureValid2) {
+          return {
+            valid: false,
+            error: `Message ${i}: Server signature verification failed`
+          };
+        }
+      }
+    }
+    const { sha256 } = await import("@noble/hashes/sha256");
+    const { bytesToHex } = await import("@noble/hashes/utils");
+    const canonicalPayload = (0, import_utils.canonicalizeJson)(payload);
+    const computedHash = "sha256:" + bytesToHex(sha256(new TextEncoder().encode(canonicalPayload)));
+    if (computedHash !== meta.hash) {
+      return {
+        valid: false,
+        error: "Hash mismatch - content has been tampered",
+        hashValid: false,
+        hasSignature: !!meta.signature
+      };
+    }
+    const signatures = [];
+    let signatureValid;
+    if (meta.signature) {
+      const { Ed25519PublicKey } = await import("../../keypairs/ed25519/publickey.js");
+      const sigArray = Array.isArray(meta.signature) ? meta.signature : [meta.signature];
+      let allValid = true;
+      for (const sig of sigArray) {
+        let pkToUse;
+        const pk = sig.publicKey;
+        if (pk.startsWith("0x")) {
+          const buffer = Buffer.from(pk.slice(2), "hex");
+          if (buffer.length === 33) {
+            pkToUse = buffer.slice(1).toString("base64");
+          } else if (buffer.length === 32) {
+            pkToUse = buffer.toString("base64");
+          } else {
+            let address;
+            try {
+              const pubKey = new Ed25519PublicKey(pk.slice(2));
+              address = pubKey.toWAddress();
+            } catch {
+            }
+            signatures.push({
+              publicKey: pk,
+              address,
+              valid: false
+            });
+            allValid = false;
+            continue;
+          }
+        } else {
+          try {
+            const buffer = Buffer.from(pk, "base64");
+            if (buffer.length === 33) {
+              pkToUse = buffer.slice(1).toString("base64");
+            } else if (buffer.length === 32) {
+              pkToUse = buffer.toString("base64");
+            } else {
+              let address;
+              try {
+                const pubKey = new Ed25519PublicKey(pk);
+                address = pubKey.toWAddress();
+              } catch {
+              }
+              signatures.push({
+                publicKey: pk,
+                address,
+                valid: false
+              });
+              allValid = false;
+              continue;
+            }
+          } catch {
+            pkToUse = pk;
+          }
+        }
+        try {
+          const pubKey = new Ed25519PublicKey(pkToUse);
+          const signatureBytes = Uint8Array.from(
+            Buffer.from(sig.value, "base64")
+          );
+          const signValid = await pubKey.verify(
+            new TextEncoder().encode(meta.hash),
+            signatureBytes
+          );
+          let address;
+          try {
+            address = pubKey.toWAddress();
+          } catch {
+          }
+          signatures.push({
+            publicKey: pk,
+            address,
+            valid: signValid
+          });
+          if (!signValid) {
+            allValid = false;
+          }
+        } catch {
+          let address;
+          try {
+            const pubKey = new Ed25519PublicKey(pkToUse);
+            address = pubKey.toWAddress();
+          } catch {
+          }
+          signatures.push({ publicKey: pk, address, valid: false });
+          allValid = false;
+        }
+      }
+      signatureValid = allValid;
+      if (!signatureValid) {
+        const failedAddresses = signatures.filter((s) => !s.valid && s.address).map((s) => s.address);
+        return {
+          valid: false,
+          error: `Signatures from the following addresses are invalid: ${failedAddresses.join(", ")}`,
+          hashValid: true,
+          hasSignature: true,
+          signatureValid: false,
+          signatures
+        };
+      }
+    }
+    return {
+      valid: true,
+      hashValid: true,
+      hasSignature: !!meta.signature,
+      signatureValid,
+      signatures: signatures.length > 0 ? signatures : void 0
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: `Verification error: ${error}`,
+      hashValid: false,
+      hasSignature: false
+    };
+  }
+}
+async function sign_wts(wtsFilePath, account, outputPath) {
+  const verifyResult = await verify_wts(wtsFilePath);
+  if (!verifyResult.valid) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_INPUT,
+      `WTS file verification failed: ${verifyResult.error}`
+    );
+  }
+  const wtsFile = load_wts(wtsFilePath);
+  const address = await import_account.Account.Instance().get_address(account);
+  if (!address) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.AccountNotFound, `sign_wts.account ${account}`);
+  }
+  const signResult = await import_account.Account.Instance().signData(
+    address,
+    wtsFile.meta.hash
+  );
+  let publicKeyBase64;
+  const pk = signResult.publicKey;
+  if (pk.startsWith("0x")) {
+    const buffer = Buffer.from(pk.slice(2), "hex");
+    if (buffer.length === 33) {
+      publicKeyBase64 = buffer.slice(1).toString("base64");
+    } else if (buffer.length === 32) {
+      publicKeyBase64 = buffer.toString("base64");
+    } else {
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.INVALID_INPUT,
+        `Invalid public key length: ${buffer.length}, expected 32 or 33 bytes`
+      );
+    }
+  } else {
+    publicKeyBase64 = pk;
+  }
+  const newSignature = {
+    value: Buffer.from(signResult.signature.slice(2), "hex").toString(
+      "base64"
+    ),
+    publicKey: publicKeyBase64,
+    algorithm: "Ed25519",
+    address: signResult.address
+  };
+  let signatures;
+  if (wtsFile.meta.signature) {
+    const existingSigs = Array.isArray(wtsFile.meta.signature) ? [...wtsFile.meta.signature] : [wtsFile.meta.signature];
+    const existingIndex = existingSigs.findIndex(
+      (sig) => sig.publicKey === publicKeyBase64
+    );
+    if (existingIndex >= 0) {
+      existingSigs[existingIndex] = newSignature;
+      signatures = existingSigs;
+    } else {
+      signatures = [...existingSigs, newSignature];
+    }
+  } else {
+    signatures = [newSignature];
+  }
+  const signedWtsFile = {
+    ...wtsFile,
+    meta: {
+      ...wtsFile.meta,
+      signature: signatures
+    }
+  };
+  let savePath;
+  if (outputPath) {
+    savePath = outputPath;
+  } else {
+    const dir = path.dirname(wtsFilePath);
+    const ext = path.extname(wtsFilePath);
+    const baseName = path.basename(wtsFilePath, ext);
+    savePath = path.join(dir, `signed_${baseName}${ext}`);
+  }
+  save_wts(signedWtsFile, savePath);
+  return savePath;
+}
+async function wts2html(wtsPath, options = {}) {
+  const fs2 = await import("fs");
+  const path2 = await import("path");
+  const stats = fs2.statSync(wtsPath);
+  if (stats.isDirectory()) {
+    const files = fs2.readdirSync(wtsPath);
+    const wtsFiles = files.filter((f) => f.endsWith(".wts"));
+    if (wtsFiles.length === 0) {
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.INVALID_INPUT,
+        `No .wts files found in directory: ${wtsPath}`
+      );
+    }
+    const results = [];
+    for (const file of wtsFiles) {
+      const filePath = path2.join(wtsPath, file);
+      const html = await convertWtsToHtml(filePath, options);
+      const outputFileName = file.replace(".wts", ".html");
+      const outputFilePath = options.outputPath ? path2.join(options.outputPath, outputFileName) : path2.join(wtsPath, outputFileName);
+      const outputDir = path2.dirname(outputFilePath);
+      if (!fs2.existsSync(outputDir)) {
+        fs2.mkdirSync(outputDir, { recursive: true });
+      }
+      fs2.writeFileSync(outputFilePath, html, "utf-8");
+      results.push(outputFilePath);
+    }
+    return results;
+  }
+  return convertWtsToHtml(wtsPath, options);
+}
+async function convertWtsToHtml(wtsFilePath, options = {}) {
+  const fs2 = await import("fs");
+  const path2 = await import("path");
+  const { title = "WTS Document", theme = "light" } = options;
+  const verifyResult = await verify_wts(wtsFilePath);
+  const wtsFile = load_wts(wtsFilePath);
+  const { payload, meta } = wtsFile;
+  const bgColor = theme === "dark" ? "#1a1a1a" : "#ffffff";
+  const textColor = theme === "dark" ? "#e0e0e0" : "#333333";
+  const borderColor = theme === "dark" ? "#444444" : "#e0e0e0";
+  const escapeHtml = (text) => {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  };
+  const isNonTextMessage = (msg) => {
+    return !!msg.zipMetadata;
+  };
+  const getFileTypeLabel = (msg) => {
+    if (msg.zipMetadata?.contentType) {
+      return msg.zipMetadata.contentType.toUpperCase();
+    }
+    const fileName = msg.zipMetadata?.fileName || "";
+    if (fileName.endsWith(".wts")) return "WTS";
+    if (fileName.endsWith(".wip")) return "WIP";
+    if (fileName.endsWith(".zip")) return "ZIP";
+    if (fileName.endsWith(".json")) return "JSON";
+    if (fileName.endsWith(".txt")) return "TXT";
+    if (msg.zipMetadata) return "ZIP";
+    return "FILE";
+  };
+  const generateSaveButton = (msg, index) => {
+    const fileType = getFileTypeLabel(msg);
+    const fileName = msg.zipMetadata?.fileName || `message_${index}.${fileType.toLowerCase()}`;
+    const fileData = msg.plaintext || "";
+    return `
+			<div style="margin: 12px 0; padding: 16px; background: ${theme === "dark" ? "#2a3f2a" : "#e8f5e9"}; border: 1px solid ${theme === "dark" ? "#4caf50" : "#81c784"}; border-radius: 8px; text-align: center;">
+				<div style="font-size: 14px; color: ${theme === "dark" ? "#81c784" : "#2e7d32"}; margin-bottom: 8px;">
+					\u{1F4CE} ${fileType} File
+					${msg.zipMetadata ? `<span style="font-size: 12px; color: #666;">(${formatFileSize(msg.zipMetadata.fileSize)})</span>` : ""}
+				</div>
+				<button 
+					onclick="saveFile${index}()"
+					style="padding: 10px 24px; background: #4caf50; color: white; border: none; border-radius: 4px; cursor: pointer; font-size: 14px;"
+					onmouseover="this.style.background='#45a049'"
+					onmouseout="this.style.background='#4caf50'"
+				>
+					\u{1F4BE} Save ${escapeHtml(fileName)}
+				</button>
+			</div>
+			<script>
+				function saveFile${index}() {
+					try {
+						// Base64 \u89E3\u7801
+						const base64Data = "${escapeHtml(fileData)}";
+						const byteCharacters = atob(base64Data);
+						const byteNumbers = new Array(byteCharacters.length);
+						for (let i = 0; i < byteCharacters.length; i++) {
+							byteNumbers[i] = byteCharacters.charCodeAt(i);
+						}
+						const byteArray = new Uint8Array(byteNumbers);
+						
+						// \u6839\u636E\u6587\u4EF6\u7C7B\u578B\u8BBE\u7F6E MIME \u7C7B\u578B
+						let mimeType = "application/octet-stream";
+						const fileName = "${escapeHtml(fileName)}";
+						if (fileName.endsWith('.json')) mimeType = "application/json";
+						else if (fileName.endsWith('.zip')) mimeType = "application/zip";
+						else if (fileName.endsWith('.txt')) mimeType = "text/plain";
+						
+						const blob = new Blob([byteArray], { type: mimeType });
+						const url = URL.createObjectURL(blob);
+						const a = document.createElement("a");
+						a.href = url;
+						a.download = fileName;
+						document.body.appendChild(a);
+						a.click();
+						document.body.removeChild(a);
+						URL.revokeObjectURL(url);
+					} catch (e) {
+						alert('\u4FDD\u5B58\u6587\u4EF6\u5931\u8D25: ' + e.message);
+					}
+				}
+			<\/script>
+		`;
+  };
+  const formatFileSize = (bytes) => {
+    if (bytes < 1024) return bytes + " B";
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + " KB";
+    return (bytes / (1024 * 1024)).toFixed(1) + " MB";
+  };
+  const messagesHtml = payload.messages.map((msg, index) => {
+    const isNonText = isNonTextMessage(msg);
+    return `
+			<div style="margin: 16px 0; padding: 16px; border: 1px solid ${borderColor}; border-radius: 8px; background: ${theme === "dark" ? "#2a2a2a" : "#f9f9f9"};">
+				<div style="display: flex; justify-content: space-between; margin-bottom: 8px; font-size: 12px; color: #666;">
+					<span>From: ${escapeHtml(msg.from.slice(0, 20))}... To: ${escapeHtml(msg.to.slice(0, 20))}...</span>
+					<span>${new Date(msg.timestamp).toLocaleString()}</span>
+				</div>
+				${isNonText ? generateSaveButton(msg, index) : msg.plaintext ? `<div style="margin: 12px 0; padding: 12px; background: ${theme === "dark" ? "#333333" : "#ffffff"}; border: 1px solid ${borderColor}; border-radius: 4px; font-size: 14px; line-height: 1.6; max-height: calc(1.6em * 6); overflow-y: auto; white-space: pre-wrap; word-break: break-word;">${escapeHtml(msg.plaintext)}</div>` : ""}
+				<div style="margin: 8px 0; font-size: 11px; color: #666;">
+					<div>Plaintext Hash: ${escapeHtml(msg.plaintextHash)}</div>
+					${msg.arkConfirmed ? `<div>ARK Confirmed: ${escapeHtml(msg.arkConfirmed.recipient)} at ${new Date(msg.arkConfirmed.timestamp).toLocaleString()}</div>` : ""}
+					${msg.guardAddress ? `<div>Guard: ${escapeHtml(msg.guardAddress)}</div>` : ""}
+					${msg.passportAddress ? `<div>Passport: ${escapeHtml(msg.passportAddress)}</div>` : ""}
+				</div>
+				<div style="font-size: 11px; color: #888; margin-top: 8px; padding-top: 8px; border-top: 1px solid ${borderColor};">
+					<div>Leaf Index: ${msg.leafIndex}</div>
+					<div style="word-break: break-all;">Merkle Root: ${escapeHtml(msg.merkleRoot)}</div>
+					<div style="word-break: break-all;">Server Sig: ${escapeHtml(msg.serverSignature.slice(0, 50))}...</div>
+				</div>
+			</div>
+		`;
+  }).join("");
+  const signatureHtml = "";
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${escapeHtml(title)}</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background: ${bgColor};
+            color: ${textColor};
+        }
+        .header {
+            border-bottom: 2px solid ${borderColor};
+            padding-bottom: 16px;
+            margin-bottom: 24px;
+        }
+        .meta {
+            font-size: 12px;
+            color: #666;
+            margin-top: 8px;
+        }
+        .note {
+            font-size: 11px;
+            color: #999;
+            margin-top: 12px;
+            padding: 8px;
+            background: ${theme === "dark" ? "#2a2a2a" : "#f5f5f5"};
+            border-radius: 4px;
+            font-style: italic;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>Witness Timestamped Sequence</h1>
+        <div class="note">
+            Important Note: This page is for message browsing and verification reference only. Please verify whether the message sequence has been tampered with through the API using the WTS file.
+        </div>
+        <div style="font-size: 14px; color: #666; margin-top: 4px;">
+            ${new Date(meta.startTime).toLocaleDateString()} - ${new Date(meta.endTime).toLocaleDateString()}
+            ${verifyResult.valid ? `<span style="color: #4caf50; margin-left: 8px;">\u2713 The accuracy, sequentiality, and integrity of the messages are verified without tampering</span>` : `<span style="color: #ff9800; margin-left: 8px;">\u26A0 ${verifyResult.error || "Hash mismatch - content has been tampered"}</span>`}
+        </div>
+        <div class="meta">
+            <div>Session: ${escapeHtml(payload.session.id)}</div>
+            <div>Participants: ${payload.session.participants.map((p) => escapeHtml(p.slice(0, 20)) + "...").join(", ")}</div>
+            <div>Messages: ${meta.messageCount} | Time: ${new Date(meta.startTime).toLocaleString()} - ${new Date(meta.endTime).toLocaleString()}</div>
+            <div style="word-break: break-all;">Merkle Root: ${escapeHtml(meta.merkleRoot)}</div>
+            ${verifyResult.signatures && verifyResult.signatures.length > 0 ? `
+            <div style="margin-top: 8px; padding: 8px; background: ${theme === "dark" ? "#2a3f2a" : "#e8f5e9"}; border-radius: 4px;">
+                <div style="font-size: 11px; color: ${theme === "dark" ? "#81c784" : "#2e7d32"}; margin-bottom: 4px;">\u2713 Signature Verification (${verifyResult.signatures.length} signature${verifyResult.signatures.length > 1 ? "s" : ""})</div>
+                ${verifyResult.signatures.map(
+    (s, idx) => `
+                    <div style="font-size: 10px; color: ${textColor}; margin-left: 8px;">
+                        ${idx + 1}. ${s.address ? escapeHtml(s.address.slice(0, 20)) + "..." : "Unknown"}: ${s.valid ? '<span style="color: #4caf50;">\u2713 Valid</span>' : '<span style="color: #f44336;">\u2717 Invalid</span>'}
+                    </div>
+                `
+  ).join("")}
+            </div>
+            ` : ""}
+        </div>
+    </div>
+    <div class="messages">
+        ${messagesHtml}
+    </div>
+    ${signatureHtml}
+</body>
+</html>`;
+  if (options.outputPath) {
+    const dir = path2.dirname(options.outputPath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(options.outputPath, html, "utf-8");
+    return options.outputPath;
+  }
+  return html;
+}
+async function proof_message(account, messageId, network) {
+  const address = await import_account.Account.Instance().get_address(account);
+  if (!address) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.AccountNotFound, `proof_message.account ${account}`);
+  }
+  const messageStorage = new import_storage.MessageStorage(address);
+  const message = messageStorage.getMessageById(messageId);
+  if (!message) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_INPUT,
+      `Message not found: ${messageId}`
+    );
+  }
+  if (message.fromAddress.toLowerCase() !== address.toLowerCase() && message.toAddress.toLowerCase() !== address.toLowerCase()) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_INPUT,
+      `Message does not belong to account ${address}`
+    );
+  }
+  if (!message.serverSignature) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_PROOF,
+      `Message does not have server signature`
+    );
+  }
+  if (!message.serverPublicKey) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_PROOF,
+      `Message does not have server public key`
+    );
+  }
+  if (!message.plaintext) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_PROOF,
+      `Message does not have plaintext`
+    );
+  }
+  const { verifyMessage } = await import("./crypto.js");
+  const verifyParams = {
+    messageId: message.messageId,
+    plaintext: message.plaintext,
+    plaintextHash: message.plaintextHash,
+    createdAt: message.createdAt,
+    guardAddress: message.guardAddress,
+    passportAddress: message.passportAddress,
+    serverSignature: message.serverSignature,
+    serverPublicKey: message.serverPublicKey
+  };
+  if (message.newRoot && message.leafIndex !== void 0) {
+    if (!message.serverTimestamp) {
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.INVALID_PROOF,
+        `Message ${message.messageId} missing server timestamp for verification`
+      );
+    }
+    verifyParams.merkleMetadata = {
+      newRoot: message.newRoot,
+      prevRoot: message.prevRoot,
+      leafIndex: message.leafIndex,
+      serverTimestamp: message.serverTimestamp
+      // 必须使用服务器时间戳
+      // 注意：proofSiblings 和 proofIndices 从服务器拉取时不提供
+      // verifyMessage 会跳过 Merkle Proof 验证，只验证 Root 计算
+    };
+  }
+  const verifyResult = verifyMessage(verifyParams);
+  if (!verifyResult.valid) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_PROOF,
+      `Message verification failed: ${verifyResult.error}`
+    );
+  }
+  if (!message.serverPublicKey) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_PROOF,
+      `Message does not have server public key`
+    );
+  }
+  const { CallProof } = await import("../call/proof.js");
+  const callProof = new CallProof({
+    proof: message.newRoot,
+    // 证明root存在
+    server_pubkey: message.serverPublicKey,
+    server_signature: message.serverSignature,
+    proof_type: import_types.CHAIN_PROOF_TYPE,
+    // 消息证明类型
+    description: `Message proof for ${messageId}`,
+    item_count: message.leafIndex ?? 1,
+    about_address: message.fromAddress.toLowerCase() === address.toLowerCase() ? message.toAddress : message.fromAddress
+  });
+  const env = {
+    network,
+    account: address
+  };
+  const result = await callProof.call(env);
+  const { ResponseData: extractResponseData } = await import("../call/base.js");
+  const responseData = extractResponseData(result);
+  const proofResult = responseData.find((item) => item.type === "Proof");
+  if (!proofResult || !proofResult.object) {
+    throw new import_types.MessengerError(
+      import_types.MessengerErrorCode.INVALID_PROOF,
+      `Failed to get proof address from transaction result`
+    );
+  }
+  message.proof = proofResult.object;
+  messageStorage.saveMessage(message);
+  return { proofAddress: proofResult.object };
+}
+const MIN_PASSPORT_VALIDITY = 10;
+const MAX_PASSPORT_VALIDITY = 10 * 365 * 24 * 60 * 60;
+const MAX_BLACKLIST_SIZE_ONCE = 100;
+const MAX_FRIENDS_SIZE_ONCE = 100;
+const MAX_GUARDS_SIZE_ONCE = 10;
+async function blacklist(request) {
+  const acc = await import_account.Account.Instance().get_address(request.account);
+  if (!acc) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `blacklist.account ${request.account}`
+    );
+  }
+  const manager = getMessengerManager();
+  switch (request.op) {
+    case "add": {
+      let addresses = await (0, import_local2.GetManyAccountOrMark_Address)(request.users);
+      if (addresses.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `blacklist.add.users ${request.users} have not valid addresses`
+        );
+      }
+      addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
+      if (addresses.length > MAX_BLACKLIST_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `blacklist.add.users ${request.users} have too many addresses, max ${MAX_BLACKLIST_SIZE_ONCE}`
+        );
+      }
+      const result = await manager.addToBlacklist(acc, addresses);
+      return { op: "add", result };
+    }
+    case "remove": {
+      let addresses = await (0, import_local2.GetManyAccountOrMark_Address)(request.users);
+      if (addresses.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `blacklist.remove.users ${request.users} have not valid addresses`
+        );
+      }
+      addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
+      if (addresses.length > MAX_BLACKLIST_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `blacklist.remove.users ${request.users} have too many addresses, max ${MAX_BLACKLIST_SIZE_ONCE}`
+        );
+      }
+      const result = await manager.removeFromBlacklist(acc, addresses);
+      return { op: "remove", result };
+    }
+    case "clear": {
+      const result = await manager.clearBlacklist(acc);
+      return { op: "clear", result };
+    }
+    case "get": {
+      const result = await manager.getBlacklist(acc);
+      return { op: "get", result };
+    }
+    case "exist": {
+      let addresses = await (0, import_local2.GetManyAccountOrMark_Address)(request.users);
+      if (addresses.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `blacklist.exist.users ${request.users} have not valid addresses`
+        );
+      }
+      addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
+      if (addresses.length > MAX_BLACKLIST_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `blacklist.exist.users ${request.users} have too many addresses, max ${MAX_BLACKLIST_SIZE_ONCE}`
+        );
+      }
+      const result = await manager.existInBlacklist(acc, addresses);
+      return { op: "exist", result };
+    }
+    default:
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.INVALID_INPUT,
+        `blacklist.unknown op: ${request}`
+      );
+  }
+}
+async function friendslist(request) {
+  const acc = await import_account.Account.Instance().get_address(request.account);
+  if (!acc) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `friendslist.account ${request.account}`
+    );
+  }
+  const manager = getMessengerManager();
+  switch (request.op) {
+    case "add": {
+      let addresses = await (0, import_local2.GetManyAccountOrMark_Address)(request.users);
+      if (addresses.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `friendslist.add.users ${request.users} have not valid addresses`
+        );
+      }
+      addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
+      const result = await manager.addToFriendsList(acc, addresses);
+      return { op: "add", result };
+    }
+    case "remove": {
+      let addresses = await (0, import_local2.GetManyAccountOrMark_Address)(request.users);
+      if (addresses.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `friendslist.remove.users ${request.users} have not valid addresses`
+        );
+      }
+      addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
+      if (addresses.length > MAX_FRIENDS_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `friendslist.remove.users ${request.users} have too many addresses, max ${MAX_FRIENDS_SIZE_ONCE}`
+        );
+      }
+      const result = await manager.removeFromFriendsList(acc, addresses);
+      return { op: "remove", result };
+    }
+    case "clear": {
+      const result = await manager.clearFriendsList(acc);
+      return { op: "clear", result };
+    }
+    case "get": {
+      const result = await manager.getFriendsList(acc);
+      return { op: "get", result };
+    }
+    case "exist": {
+      let addresses = await (0, import_local2.GetManyAccountOrMark_Address)(request.users);
+      if (addresses.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `friendslist.exist.users ${request.users} have not valid addresses`
+        );
+      }
+      addresses = [...new Set(addresses.map((a) => a.toLowerCase()))];
+      if (addresses.length > MAX_FRIENDS_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `friendslist.exist.users ${request.users} have too many addresses, max ${MAX_FRIENDS_SIZE_ONCE}`
+        );
+      }
+      const result = await manager.existInFriendsList(acc, addresses);
+      return { op: "exist", result };
+    }
+    default:
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.INVALID_INPUT,
+        `friendslist.unknown op: ${request}`
+      );
+  }
+}
+async function guardlist(request) {
+  const acc = await import_account.Account.Instance().get_address(request.account);
+  if (!acc) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.AccountNotFound,
+      `guardlist.account ${request.account}`
+    );
+  }
+  const manager = getMessengerManager();
+  switch (request.op) {
+    case "add": {
+      const uniqueGuardsMap = /* @__PURE__ */ new Map();
+      for (const g of request.guards) {
+        uniqueGuardsMap.set(g.guard.toLowerCase(), g);
+      }
+      const guards = Array.from(uniqueGuardsMap.values());
+      if (guards.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `guardlist.add.guards ${request.guards} have not valid guards`
+        );
+      }
+      if (guards.length > MAX_GUARDS_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `guardlist.add.guards ${request.guards} have too many guards, max ${MAX_GUARDS_SIZE_ONCE}`
+        );
+      }
+      for (const g of guards) {
+        if (!(0, import_common.isValidU64)(g.passportValiditySeconds) || g.passportValiditySeconds < MIN_PASSPORT_VALIDITY || g.passportValiditySeconds > MAX_PASSPORT_VALIDITY) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `Guard ${g.guard}: passport validity ${g.passportValiditySeconds} must be between ${MIN_PASSPORT_VALIDITY} and ${MAX_PASSPORT_VALIDITY} seconds`
+          );
+        }
+      }
+      const addresses = await import_local.LocalMark.Instance().get_many_address(
+        guards.map((g) => g.guard)
+      );
+      if (addresses.length !== guards.length) {
+        const foundAddresses = new Set(addresses);
+        const missingGuards = [];
+        for (const g of guards) {
+          if (!foundAddresses.has(g.guard) && !g.guard.startsWith("0x")) {
+            missingGuards.push(g.guard);
+          }
+        }
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Guard not found: ${missingGuards.join(", ")}`
+        );
+      }
+      const objs = await (0, import_object.query_objects)({
+        objects: addresses,
+        no_cache: false,
+        network: manager.getConfig().network
+      });
+      if (!objs || !objs.objects || objs.objects.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Guard not found: ${guards.map((g) => g.guard).join(", ")}`
+        );
+      }
+      objs.objects.forEach((obj) => {
+        if (obj.type !== "Guard") {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `Guard ${obj.object} is not a Guard`
+          );
+        }
+      });
+      const guardListItems = guards.map((g, index) => ({
+        guardAddress: addresses[index],
+        passportValiditySeconds: g.passportValiditySeconds
+      }));
+      const result = await manager.addToGuardList(acc, guardListItems);
+      return { op: "add", result };
+    }
+    case "remove": {
+      const guards = [
+        ...new Set(request.guards.map((g) => g.toLowerCase()))
+      ];
+      if (guards.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `guardlist.remove.guards ${request.guards} have not valid guards`
+        );
+      }
+      if (guards.length > MAX_GUARDS_SIZE_ONCE) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `guardlist.remove.guards ${request.guards} have too many guards, max ${MAX_GUARDS_SIZE_ONCE}`
+        );
+      }
+      const addresses = await import_local.LocalMark.Instance().get_many_address(guards);
+      if (addresses.length !== guards.length) {
+        const foundAddresses = new Set(addresses);
+        const missingGuards = [];
+        for (const g of guards) {
+          if (!foundAddresses.has(g) && !g.startsWith("0x")) {
+            missingGuards.push(g);
+          }
+        }
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Guard not found: ${missingGuards.join(", ")}`
+        );
+      }
+      const result = await manager.removeFromGuardList(
+        acc,
+        addresses
+      );
+      return { op: "remove", result };
+    }
+    case "get": {
+      const result = await manager.getGuardList(acc);
+      return { op: "get", result };
+    }
+    default:
+      throw new import_types.MessengerError(
+        import_types.MessengerErrorCode.INVALID_INPUT,
+        `guardlist.unknown op: ${request}`
+      );
+  }
+}