wowok 1.8.3 → 2.1.10

package/dist/cjs/w/call/guard.js

@@ -0,0 +1,1203 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var guard_exports = {};
+__export(guard_exports, {
+  CallGuard: () => CallGuard,
+  create: () => create,
+  formatGuardParseErrors: () => formatGuardParseErrors,
+  gen_passport: () => gen_passport,
+  generateNodeComments: () => generateNodeComments,
+  guard2file: () => guard2file,
+  guardFn: () => guardFn,
+  newGuard: () => newGuard,
+  parseGuardFile: () => parseGuardFile,
+  parseGuardFromMarkdown: () => parseGuardFromMarkdown,
+  reliesAdd: () => reliesAdd,
+  reliesClear: () => reliesClear,
+  reliesLogic: () => reliesLogic,
+  reliesRemove: () => reliesRemove,
+  validateGuardNode: () => validateGuardNode
+});
+module.exports = __toCommonJS(guard_exports);
+var import_common = require("../common.js");
+var import_lodash = __toESM(require("lodash"));
+var import_exception = require("../exception.js");
+var import_base = require("./base.js");
+var import_local = require("../local/local.js");
+var import_object = require("../query/object.js");
+var import_bcs = require("../../bcs/index.js");
+var import_util = require("../util.js");
+var import_guard_ins = require("./guard-ins.js");
+var import_util2 = require("./util.js");
+var import_sui_types = require("../../utils/sui-types.js");
+var import_passport = require("./passport.js");
+var import_fs = require("fs");
+var import_path = require("path");
+function guardFn(name) {
+  return `${import_common.PackageAddress}::guard::${name}`;
+}
+class CallGuard extends import_base.CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    this.data = data;
+  }
+  async call(env) {
+    await this.prepare(env);
+    return await this.exec(env);
+  }
+  async operate(env, tx, _passport, _submission) {
+    if (!this.data.table || this.data.table.length === 0) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "table is empty");
+    }
+    if (!this.data.root) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "root is empty");
+    }
+    const guard = await newGuard(
+      tx,
+      this.data?.description || "",
+      this.data?.table,
+      this.data?.root
+    );
+    if (this.data?.rely != null) {
+      const relyGuards = await import_local.LocalMark.Instance().get_many_address(
+        this.data.rely.guards
+      );
+      const undefinedIndex = relyGuards.findIndex((v) => v === void 0);
+      if (undefinedIndex !== -1) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `rely.guards invalid: guard at index ${undefinedIndex} not found`
+        );
+      }
+      reliesAdd(
+        tx,
+        guard,
+        relyGuards.filter((v) => v !== void 0)
+      );
+    }
+    await this.new_with_mark(
+      env,
+      tx,
+      import_common.ObjectType.Guard,
+      create(tx, guard),
+      this.data?.namedNew
+    );
+  }
+}
+const newGuard = async (tx, description, table, root) => {
+  if (!(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  for (let i = 0; i < table.length; i++) {
+    const v = table[i];
+    if (!(0, import_common.isValidU8)(v.identifier))
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `table.identifier ${v.identifier} invalid`
+      );
+    if (!v.b_submission && (v.value === void 0 || v.value === null))
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `table.value ${v.value} with identifier ${v.identifier} invalid`
+      );
+    if (!(0, import_common.isValidName)(v.name)) (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "table.name");
+  }
+  const grouped = import_lodash.default.groupBy(table, "identifier");
+  const duplicates = Object.keys(grouped).filter(
+    (key) => grouped[key].length > 1
+  );
+  if (duplicates.length > 0) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `table.identifier duplicates: ${duplicates.join(", ")}`
+    );
+  }
+  var output = [];
+  await buildNode(root, import_common.ValueType.Bool, table, output);
+  const totalLength = output.reduce((acc, arr) => acc + arr.length, 0);
+  const input = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of output) {
+    input.set(arr, offset);
+    offset += arr.length;
+  }
+  if (input.length > import_common.MAX_INPUT_SIZE) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.NewGuardCheckFailed,
+      `Input size exceeds maximum limit ${import_common.MAX_INPUT_SIZE}`
+    );
+  }
+  if (input.length === 0) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.NewGuardCheckFailed, `Input cannot be empty`);
+  }
+  const tableItems = [];
+  for (let i = 0; i < table.length; i++) {
+    const item = table[i];
+    const valueType = (0, import_common.parseValueType)(item.value_type);
+    let bcsValue;
+    if (item.b_submission) {
+      bcsValue = new Uint8Array(1);
+      bcsValue[0] = valueType;
+    } else {
+      if (item.value === void 0 || item.value === null) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.NewGuardCheckFailed,
+          `Table item value is required when b_submission is false`
+        );
+      }
+      bcsValue = await (0, import_util.valueToBcsBytes)(valueType, item.value);
+    }
+    tableItems.push(
+      tx.moveCall({
+        target: guardFn("table_item"),
+        arguments: [
+          tx.pure.u8(item.identifier),
+          tx.pure.bool(item.b_submission),
+          tx.pure.vector("u8", Array.from(bcsValue)),
+          (0, import_common.toTxString)(tx, item.name)
+        ]
+      })
+    );
+  }
+  return tx.moveCall({
+    target: guardFn("new"),
+    arguments: [
+      (0, import_common.toTxString)(tx, description),
+      tx.makeMoveVec({
+        elements: tableItems,
+        type: `${import_common.PackageAddress}::guard::TableItem`
+      }),
+      tx.pure.vector("u8", Array.from(input))
+    ]
+  });
+};
+function create(tx, guard) {
+  return tx.moveCall({
+    target: guardFn("create"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, guard),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function reliesAdd(tx, guard, rely_guards) {
+  const guards = import_lodash.default.uniq(rely_guards);
+  if (guards.length > import_common.MAX_DEPENDED_COUNT) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.NewGuardCheckFailed,
+      `Relies count exceeds maximum limit ${import_common.MAX_DEPENDED_COUNT}`
+    );
+  }
+  guards.forEach((g) => {
+    if (g === guard) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.NewGuardCheckFailed, `Guard cannot rely on itself`);
+    }
+    tx.moveCall({
+      target: guardFn("relies_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, guard),
+        (0, import_common.toTxObject)(tx, g),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  });
+}
+function reliesRemove(tx, guard, rely_guards) {
+  const guards = import_lodash.default.uniq(rely_guards);
+  if (guards.length > import_common.MAX_DEPENDED_COUNT) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.NewGuardCheckFailed,
+      `Relies count exceeds maximum limit ${import_common.MAX_DEPENDED_COUNT}`
+    );
+  }
+  guards.forEach((g) => {
+    tx.moveCall({
+      target: guardFn("relies_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, guard),
+        (0, import_common.toTxObject)(tx, g),
+        tx.object.mutRegistrar()
+      ]
+    });
+  });
+}
+function reliesClear(tx, guard) {
+  tx.moveCall({
+    target: guardFn("relies_clear"),
+    arguments: [(0, import_common.toTxObject)(tx, guard), tx.object.mutRegistrar()]
+  });
+}
+function reliesLogic(tx, guard, logic_and) {
+  tx.moveCall({
+    target: guardFn("relies_logic_and"),
+    arguments: [(0, import_common.toTxObject)(tx, guard), tx.pure.bool(logic_and)]
+  });
+}
+const buildNode = async (guard_node, type_required, table, output) => {
+  const node = guard_node;
+  switch (node.type) {
+    case "identifier": {
+      const f = table.find((v) => v.identifier === node.identifier);
+      if (f) {
+        const fValueType = (0, import_common.parseValueType)(f.value_type);
+        (0, import_util2.checkType)(fValueType, type_required, node);
+        output.push(
+          import_bcs.bcs.U8.serialize(import_common.ContextType.TypeConstant).toBytes()
+        );
+        output.push(import_bcs.bcs.U8.serialize(node.identifier).toBytes());
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "node identifier - " + JSON.stringify(node)
+        );
+      }
+      break;
+    }
+    case "query": {
+      const q = (0, import_guard_ins.getGuardQueryInfo)(node.query);
+      if (!q) {
+        (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `query not found: ${node.query}`);
+      }
+      (0, import_util2.checkType)(q.return, type_required, node);
+      if (q.parameters.length === node.parameters.length) {
+        for (let i = node.parameters.length - 1; i >= 0; --i) {
+          await buildNode(
+            node.parameters[i],
+            q.parameters[i],
+            table,
+            output
+          );
+        }
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "node query parameters length not match - " + JSON.stringify(node)
+        );
+      }
+      const tableItem = table.find(
+        (v) => v.identifier === node.object.identifier
+      );
+      if (!tableItem) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "node object from identifier - " + JSON.stringify(node)
+        );
+      }
+      const tableItemValueType = (0, import_common.parseValueType)(tableItem.value_type);
+      if (tableItemValueType !== import_common.ValueType.Address) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `object to query must be address in table ${tableItem}. ${node.object}`
+        );
+      }
+      output.push(import_bcs.bcs.U8.serialize(import_common.OperatorType.TypeQuery).toBytes());
+      if ((0, import_common.isWitnessType)(node.object.convert_witness)) {
+        const target = (0, import_object.WitnessTargetType)(node.object.convert_witness);
+        if (target !== q.objectType) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `witness object type(${target}) not consistent with query object type(${q.objectType})`
+          );
+        }
+        const source = (0, import_object.WitnessSourceType)(node.object.convert_witness);
+        if (tableItem.object_type) {
+          if (tableItem.object_type !== source) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `witness object type(${source}) not consistent with query object type(${tableItem.object_type})`
+            );
+          }
+        } else {
+          tableItem.object_type = source;
+        }
+        output.push(
+          import_bcs.bcs.U8.serialize(node.object.convert_witness).toBytes()
+        );
+      } else {
+        if (tableItem?.object_type) {
+          if (tableItem.object_type !== q.objectType) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `witness object type(${q.objectType}) not consistent with query object type(${tableItem.object_type})`
+            );
+          }
+        } else {
+          tableItem.object_type = q.objectType;
+        }
+        output.push(
+          import_bcs.bcs.U8.serialize(import_common.ContextType.TypeConstant).toBytes()
+        );
+      }
+      output.push(import_bcs.bcs.U8.serialize(node.object.identifier).toBytes());
+      output.push(import_bcs.bcs.U16.serialize(q.id).toBytes());
+      break;
+    }
+    case "logic_as_u256_greater_or_equal":
+    case "logic_as_u256_lesser_or_equal":
+    case "logic_as_u256_equal":
+    case "logic_as_u256_greater":
+    case "logic_as_u256_lesser":
+    case "logic_equal":
+    case "logic_and":
+    case "logic_or":
+    case "logic_string_contains":
+    case "logic_string_nocase_contains":
+    case "logic_string_nocase_equal":
+    case "calc_number_add":
+    case "calc_number_subtract":
+    case "calc_number_multiply":
+    case "calc_number_divide":
+    case "calc_number_mod":
+    case "calc_string_nocase_contains":
+    case "calc_string_nocase_equal":
+    case "calc_string_contains": {
+      const opCodeMap = {
+        logic_as_u256_greater_or_equal: import_common.OperatorType.TypeLogicAsU256GreaterEqual,
+        logic_as_u256_lesser_or_equal: import_common.OperatorType.TypeLogicAsU256LesserEqual,
+        logic_as_u256_equal: import_common.OperatorType.TypeLogicAsU256Equal,
+        logic_as_u256_greater: import_common.OperatorType.TypeLogicAsU256Greater,
+        logic_as_u256_lesser: import_common.OperatorType.TypeLogicAsU256Lesser,
+        logic_equal: import_common.OperatorType.TypeLogicEqual,
+        logic_and: import_common.OperatorType.TypeLogicAnd,
+        logic_or: import_common.OperatorType.TypeLogicOr,
+        logic_string_contains: import_common.OperatorType.TypeStringContains,
+        logic_string_nocase_contains: import_common.OperatorType.TypeStringNocaseContains,
+        logic_string_nocase_equal: import_common.OperatorType.TypeStringNocaseEqual,
+        calc_number_add: import_common.OperatorType.TypeNumberAdd,
+        calc_number_subtract: import_common.OperatorType.TypeNumberSubtract,
+        calc_number_multiply: import_common.OperatorType.TypeNumberMultiply,
+        calc_number_divide: import_common.OperatorType.TypeNumberDivide,
+        calc_number_mod: import_common.OperatorType.TypeNumberMod,
+        calc_string_nocase_contains: import_common.OperatorType.TypeStringNocaseContains,
+        calc_string_nocase_equal: import_common.OperatorType.TypeStringNocaseEqual,
+        calc_string_contains: import_common.OperatorType.TypeStringContains
+      };
+      const requiredTypeMap = {
+        logic_as_u256_greater_or_equal: "number",
+        logic_as_u256_lesser_or_equal: "number",
+        logic_as_u256_equal: "number",
+        logic_as_u256_greater: "number",
+        logic_as_u256_lesser: "number",
+        logic_equal: "variable",
+        logic_and: import_common.ValueType.Bool,
+        logic_or: import_common.ValueType.Bool,
+        logic_string_contains: import_common.ValueType.String,
+        logic_string_nocase_contains: import_common.ValueType.String,
+        logic_string_nocase_equal: import_common.ValueType.String,
+        calc_number_add: "number",
+        calc_number_subtract: "number",
+        calc_number_multiply: "number",
+        calc_number_divide: "number",
+        calc_number_mod: "number",
+        calc_string_nocase_contains: import_common.ValueType.String,
+        calc_string_nocase_equal: import_common.ValueType.String,
+        calc_string_contains: import_common.ValueType.String
+      };
+      const returnTypeMap = {
+        logic_as_u256_greater_or_equal: import_common.ValueType.Bool,
+        logic_as_u256_lesser_or_equal: import_common.ValueType.Bool,
+        logic_as_u256_equal: import_common.ValueType.Bool,
+        logic_as_u256_greater: import_common.ValueType.Bool,
+        logic_as_u256_lesser: import_common.ValueType.Bool,
+        logic_equal: import_common.ValueType.Bool,
+        logic_and: import_common.ValueType.Bool,
+        logic_or: import_common.ValueType.Bool,
+        logic_string_contains: import_common.ValueType.Bool,
+        logic_string_nocase_contains: import_common.ValueType.Bool,
+        logic_string_nocase_equal: import_common.ValueType.Bool,
+        calc_number_add: import_common.ValueType.U256,
+        calc_number_subtract: import_common.ValueType.U256,
+        calc_number_multiply: import_common.ValueType.U256,
+        calc_number_divide: import_common.ValueType.U256,
+        calc_number_mod: import_common.ValueType.U256,
+        calc_string_nocase_contains: import_common.ValueType.Bool,
+        calc_string_nocase_equal: import_common.ValueType.Bool,
+        calc_string_contains: import_common.ValueType.Bool
+      };
+      (0, import_util2.checkType)(returnTypeMap[node.type], type_required, node);
+      await multi_operand_op(
+        opCodeMap[node.type],
+        node.nodes,
+        requiredTypeMap[node.type],
+        table,
+        output
+      );
+      break;
+    }
+    case "vec_contains_bool":
+    case "vec_contains_address":
+    case "vec_contains_string":
+    case "vec_contains_string_nocase":
+    case "vec_contains_number": {
+      const opCodeMap = {
+        vec_contains_bool: import_common.OperatorType.TypedValueVecContains_Bool,
+        vec_contains_address: import_common.OperatorType.TypedValueVecContains_Address,
+        vec_contains_string: import_common.OperatorType.TypedValueVecContains_String,
+        vec_contains_string_nocase: import_common.OperatorType.TypedValueVecContains_StringNoCase,
+        vec_contains_number: import_common.OperatorType.TypedValueVecContains_Number
+      };
+      const vecTypeMap = {
+        vec_contains_bool: import_common.ValueType.VecBool,
+        vec_contains_address: import_common.ValueType.VecAddress,
+        vec_contains_string: import_common.ValueType.VecString,
+        vec_contains_string_nocase: import_common.ValueType.VecString,
+        vec_contains_number: "vec_number"
+      };
+      const elemTypeMap = {
+        vec_contains_bool: import_common.ValueType.Bool,
+        vec_contains_address: import_common.ValueType.Address,
+        vec_contains_string: import_common.ValueType.String,
+        vec_contains_string_nocase: import_common.ValueType.String,
+        vec_contains_number: "number"
+      };
+      (0, import_util2.checkType)(import_common.ValueType.Bool, type_required, node);
+      for (let i = node.nodes.length - 1; i >= 0; --i) {
+        const nodeType = i === 0 ? vecTypeMap[node.type] : elemTypeMap[node.type];
+        await buildNode(node.nodes[i], nodeType, table, output);
+      }
+      output.push(import_bcs.bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+      output.push(import_bcs.bcs.U8.serialize(node.nodes.length).toBytes());
+      break;
+    }
+    case "logic_not":
+    case "calc_string_length":
+    case "convert_number_address":
+    case "convert_address_number":
+    case "convert_number_string":
+    case "convert_string_number":
+    case "convert_safe_u8":
+    case "convert_safe_u16":
+    case "convert_safe_u32":
+    case "convert_safe_u64":
+    case "convert_safe_u128":
+    case "convert_safe_u256":
+    case "value_type":
+    case "vec_length": {
+      const opCodeMap = {
+        logic_not: import_common.OperatorType.TypeLogicNot,
+        calc_string_length: import_common.OperatorType.TypeStringLength,
+        convert_number_address: import_common.OperatorType.TypeNumberAddress,
+        convert_address_number: import_common.OperatorType.TypeAddressNumber,
+        convert_number_string: import_common.OperatorType.TypeNumberString,
+        convert_string_number: import_common.OperatorType.TypeStringNumber,
+        //convert_string_lowercase: OperatorType.TypeStringLowercase,
+        convert_safe_u8: import_common.OperatorType.TypeSafeU8,
+        convert_safe_u16: import_common.OperatorType.TypeSafeU16,
+        convert_safe_u32: import_common.OperatorType.TypeSafeU32,
+        convert_safe_u64: import_common.OperatorType.TypeSafeU64,
+        convert_safe_u128: import_common.OperatorType.TypeSafeU128,
+        convert_safe_u256: import_common.OperatorType.TypeSafeU256,
+        value_type: import_common.OperatorType.TypedValueType,
+        vec_length: import_common.OperatorType.TypedValueVecLength
+      };
+      const requiredTypeMap = {
+        logic_not: import_common.ValueType.Bool,
+        calc_string_length: import_common.ValueType.String,
+        convert_number_address: "number",
+        convert_address_number: import_common.ValueType.Address,
+        convert_number_string: "number",
+        convert_string_number: import_common.ValueType.String,
+        convert_safe_u8: "number",
+        convert_safe_u16: "number",
+        convert_safe_u32: "number",
+        convert_safe_u64: "number",
+        convert_safe_u128: "number",
+        convert_safe_u256: "number",
+        value_type: "variable",
+        vec_length: "vec"
+      };
+      const returnTypeMap = {
+        logic_not: import_common.ValueType.Bool,
+        calc_string_length: import_common.ValueType.U64,
+        convert_number_address: import_common.ValueType.Address,
+        convert_address_number: import_common.ValueType.U256,
+        convert_number_string: import_common.ValueType.String,
+        convert_string_number: import_common.ValueType.U256,
+        convert_safe_u8: import_common.ValueType.U8,
+        convert_safe_u16: import_common.ValueType.U16,
+        convert_safe_u32: import_common.ValueType.U32,
+        convert_safe_u64: import_common.ValueType.U64,
+        convert_safe_u128: import_common.ValueType.U128,
+        convert_safe_u256: import_common.ValueType.U256,
+        value_type: import_common.ValueType.U8,
+        vec_length: import_common.ValueType.U64
+      };
+      (0, import_util2.checkType)(returnTypeMap[node.type], type_required, node);
+      await single_operand_op(
+        opCodeMap[node.type],
+        node.node,
+        requiredTypeMap[node.type],
+        table,
+        output
+      );
+      break;
+    }
+    case "calc_string_indexof":
+    case "calc_string_nocase_indexof": {
+      const opCodeMap = {
+        calc_string_indexof: import_common.OperatorType.TypeStringIndexof,
+        calc_string_nocase_indexof: import_common.OperatorType.TypeStringNocaseIndexof
+      };
+      (0, import_util2.checkType)(import_common.ValueType.U64, type_required, node);
+      await buildNode(node.nodeRight, import_common.ValueType.String, table, output);
+      await buildNode(node.nodeLeft, import_common.ValueType.String, table, output);
+      output.push(import_bcs.bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+      output.push(
+        import_bcs.bcs.U8.serialize(node.order === "forward" ? 0 : 1).toBytes()
+      );
+      break;
+    }
+    case "vec_indexof_bool":
+    case "vec_indexof_address":
+    case "vec_indexof_string":
+    case "vec_indexof_string_nocase":
+    case "vec_indexof_number": {
+      const opCodeMap = {
+        vec_indexof_bool: import_common.OperatorType.TypedValueVecIndexOf_Bool,
+        vec_indexof_address: import_common.OperatorType.TypedValueVecIndexOf_Address,
+        vec_indexof_string: import_common.OperatorType.TypedValueVecIndexOf_String,
+        vec_indexof_string_nocase: import_common.OperatorType.TypedValueVecIndexOf_StringNoCase,
+        vec_indexof_number: import_common.OperatorType.TypedValueVecIndexOf_Number
+      };
+      const rightTypeMap = {
+        vec_indexof_bool: import_common.ValueType.Bool,
+        vec_indexof_address: import_common.ValueType.Address,
+        vec_indexof_string: import_common.ValueType.String,
+        vec_indexof_string_nocase: import_common.ValueType.String,
+        vec_indexof_number: "number"
+      };
+      const leftTypeMap = {
+        vec_indexof_bool: import_common.ValueType.VecBool,
+        vec_indexof_address: import_common.ValueType.VecAddress,
+        vec_indexof_string: import_common.ValueType.VecString,
+        vec_indexof_string_nocase: import_common.ValueType.VecString,
+        vec_indexof_number: "vec_number"
+      };
+      (0, import_util2.checkType)(import_common.ValueType.U64, type_required, node);
+      await buildNode(
+        node.nodeRight,
+        rightTypeMap[node.type],
+        table,
+        output
+      );
+      await buildNode(
+        node.nodeLeft,
+        leftTypeMap[node.type],
+        table,
+        output
+      );
+      output.push(import_bcs.bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+      output.push(
+        import_bcs.bcs.U8.serialize(node.order === "forward" ? 0 : 1).toBytes()
+      );
+      break;
+    }
+    case "context": {
+      let contextValue;
+      switch (node.context) {
+        case "Signer":
+          contextValue = import_common.ContextType.TypeSigner;
+          break;
+        case "Clock":
+          contextValue = import_common.ContextType.TypeClock;
+          break;
+        case "Guard":
+          contextValue = import_common.ContextType.TypeGuard;
+          break;
+        default:
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            "Invalid context type: " + node.context
+          );
+      }
+      output.push(import_bcs.bcs.U8.serialize(contextValue).toBytes());
+      (0, import_util2.checkType)(import_common.ValueType.Address, type_required, node);
+      break;
+    }
+    default:
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "node:" + JSON.stringify(node));
+  }
+};
+const multi_operand_op = async (op_code, parameters, required_type, table, output) => {
+  if (parameters.length < 2 || parameters.length > import_common.MAX_MULTI_OPERANDS) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `op ${op_code} parameters length must >= 2 and <=  
+				${import_common.MAX_MULTI_OPERANDS}. 	parameters:
+				${JSON.stringify(parameters)}`
+    );
+  }
+  for (let i = parameters.length - 1; i >= 0; --i) {
+    await buildNode(parameters[i], required_type, table, output);
+  }
+  output.push(import_bcs.bcs.U8.serialize(op_code).toBytes());
+  output.push(import_bcs.bcs.U8.serialize(parameters.length).toBytes());
+};
+const single_operand_op = async (op_code, parameter, required_type, table, output) => {
+  await buildNode(parameter, required_type, table, output);
+  output.push(import_bcs.bcs.U8.serialize(op_code).toBytes());
+};
+const guard2file = async (guard, file_path, format = "json", network) => {
+  const queryResult = await (0, import_object.query_objects)({
+    objects: [guard],
+    network
+  });
+  const objects = queryResult.objects;
+  if (!objects || objects.length === 0 || objects[0].type !== "Guard") {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `guard2file: Guard object not found: ${guard}`
+    );
+    return;
+  }
+  const guardObj = objects[0];
+  if (!guardObj) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `guard2file: Failed to get Guard object data: ${guard}`
+    );
+    return;
+  }
+  let content;
+  if (format === "json") {
+    content = generateGuardJson(guardObj);
+  } else {
+    content = generateGuardMarkdown(guardObj);
+  }
+  try {
+    const resolvedPath = (0, import_path.resolve)(file_path);
+    (0, import_fs.writeFileSync)(resolvedPath, content, "utf-8");
+  } catch (e) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `guard2file: Failed to write file '${file_path}': ${e.message}`
+    );
+  }
+};
+const generateGuardJson = (guardObj) => {
+  const output = {};
+  if (guardObj.description) {
+    output.description = guardObj.description;
+  }
+  if (guardObj.table && guardObj.table.length > 0) {
+    output.table = guardObj.table.map((item) => ({
+      identifier: item.identifier,
+      b_submission: item.b_submission,
+      value_type: item.value_type,
+      value: item.value,
+      name: item.name
+    }));
+  }
+  if (guardObj.root) {
+    output.root = guardObj.root;
+  }
+  if (guardObj.relies && guardObj.relies.length > 0) {
+    output.rely = {
+      guards: guardObj.relies,
+      logic_or: !guardObj.relies_logic_and
+    };
+  }
+  return JSON.stringify(output, null, 2);
+};
+const generateGuardMarkdown = (guardObj) => {
+  const lines = [];
+  lines.push(`# Guard Definition`);
+  lines.push("");
+  lines.push(`**Object ID:** ${guardObj.object}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  const description = guardObj.description || "";
+  const tableCount = guardObj.table ? guardObj.table.length : 0;
+  let summary = `${description.length > 100 ? description.substring(0, 97) + "..." : description}`;
+  summary += ` [${tableCount} tables]`;
+  lines.push(summary);
+  lines.push("");
+  lines.push("## Description");
+  lines.push("");
+  lines.push(guardObj.description || "");
+  lines.push("");
+  lines.push("## Table (Data Definitions)");
+  lines.push("");
+  lines.push("| Identifier | b_submission | value_type | value | name |");
+  lines.push("|------------|--------------|------------|-------|------|");
+  if (guardObj.table && guardObj.table.length > 0) {
+    for (const item of guardObj.table) {
+      const itemValueType = (0, import_common.parseValueType)(item.value_type);
+      const valueTypeStr = valueTypeToString(itemValueType);
+      const valueStr = formatValueForMarkdown(item.value);
+      lines.push(
+        `| ${item.identifier} | ${item.b_submission} | ${valueTypeStr} (${item.value_type}) | ${valueStr} | ${item.name} |`
+      );
+    }
+  } else {
+    lines.push("| - | - | - | - | - |");
+  }
+  lines.push("");
+  lines.push("## Root (Computational Tree)");
+  lines.push("");
+  lines.push("The root node MUST return a Bool value (pass/fail).");
+  lines.push("");
+  if (guardObj.root) {
+    lines.push("```json");
+    lines.push(JSON.stringify(guardObj.root, null, 2));
+    lines.push("```");
+    lines.push("");
+    const nodeComments = generateNodeComments(guardObj.root);
+    if (nodeComments.length > 0) {
+      lines.push("### Node Comments");
+      lines.push("");
+      for (const comment of nodeComments) {
+        lines.push(`- **${comment.type}**: ${comment.description}`);
+      }
+      lines.push("");
+    }
+  } else {
+    lines.push("*No root node data available*");
+    lines.push("");
+  }
+  if (guardObj.relies && guardObj.relies.length > 0) {
+    lines.push("## Rely (Dependencies)");
+    lines.push("");
+    lines.push(`**Logic:** ${guardObj.relies_logic_and ? "AND" : "OR"}`);
+    lines.push("");
+    lines.push("**Dependent Guards:**");
+    for (const rely of guardObj.relies) {
+      lines.push(`- ${rely}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+};
+const formatValueForMarkdown = (value) => {
+  if (value === void 0 || value === null) {
+    return "-";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "string") {
+    if (value.length > 30) {
+      return value.substring(0, 27) + "...";
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (value.length > 3) {
+      return `[${value.slice(0, 3).join(", ")}, ... (${value.length} items)]`;
+    }
+    return `[${value.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    return "{...}";
+  }
+  return String(value);
+};
+const generateNodeComments = (node, comments = []) => {
+  if (!node) return comments;
+  if (node.type === "query") {
+    const queryId = typeof node.query === "number" ? node.query : void 0;
+    if (queryId !== void 0) {
+      const queryInfo = import_guard_ins.GUARDQUERY.find((q) => q.id === queryId);
+      if (queryInfo) {
+        comments.push({
+          type: `query(${node.query})`,
+          description: `${queryInfo.name}: ${queryInfo.description}`
+        });
+      }
+    }
+  } else if (node.type.startsWith("logic_")) {
+    comments.push({
+      type: node.type,
+      description: `Logic operation: ${node.type.replace(/_/g, " ")}`
+    });
+  } else if (node.type.startsWith("calc_")) {
+    comments.push({
+      type: node.type,
+      description: `Calculation: ${node.type.replace(/_/g, " ")}`
+    });
+  } else if (node.type.startsWith("convert_")) {
+    comments.push({
+      type: node.type,
+      description: `Type conversion: ${node.type.replace(/_/g, " ")}`
+    });
+  }
+  if ("nodes" in node && Array.isArray(node.nodes)) {
+    for (const childNode of node.nodes) {
+      generateNodeComments(childNode, comments);
+    }
+  }
+  if ("node" in node && node.node) {
+    generateNodeComments(node.node, comments);
+  }
+  if ("parameters" in node && Array.isArray(node.parameters)) {
+    for (const param of node.parameters) {
+      generateNodeComments(param, comments);
+    }
+  }
+  if ("nodeLeft" in node && node.nodeLeft) {
+    generateNodeComments(node.nodeLeft, comments);
+  }
+  if ("nodeRight" in node && node.nodeRight) {
+    generateNodeComments(node.nodeRight, comments);
+  }
+  return comments;
+};
+const valueTypeToString = (valueType) => {
+  const typeMap = {
+    [import_common.ValueType.Bool]: "Bool",
+    [import_common.ValueType.Address]: "Address",
+    [import_common.ValueType.String]: "String",
+    [import_common.ValueType.U8]: "U8",
+    [import_common.ValueType.U16]: "U16",
+    [import_common.ValueType.U32]: "U32",
+    [import_common.ValueType.U64]: "U64",
+    [import_common.ValueType.U128]: "U128",
+    [import_common.ValueType.U256]: "U256",
+    [import_common.ValueType.VecBool]: "VecBool",
+    [import_common.ValueType.VecAddress]: "VecAddress",
+    [import_common.ValueType.VecString]: "VecString",
+    [import_common.ValueType.VecU8]: "VecU8",
+    [import_common.ValueType.VecU16]: "VecU16",
+    [import_common.ValueType.VecU32]: "VecU32",
+    [import_common.ValueType.VecU64]: "VecU64",
+    [import_common.ValueType.VecU128]: "VecU128",
+    [import_common.ValueType.VecU256]: "VecU256",
+    [import_common.ValueType.VecVecU8]: "VecVecU8",
+    [import_common.ValueType.Value]: "Value"
+  };
+  return typeMap[valueType] || `Unknown(${valueType})`;
+};
+const gen_passport = async (env, guard, info) => {
+  if (!(0, import_sui_types.isValidWowAddress)(guard)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "guard invalid: guard empty");
+  }
+  await (0, import_util2.resolveCallEnv)(env);
+  const s = await (0, import_passport.get_guardSubmissions)(env, [guard]);
+  if (s.submission.length > 0) {
+    if (!info) {
+      return {
+        type: "submission",
+        guard: s.guard,
+        submission: s.submission
+      };
+    } else {
+      return await (0, import_passport.verify_guard)(env, info);
+    }
+  } else {
+    return await (0, import_passport.verify_guard)(env, {
+      type: "submission",
+      guard: [{ object: guard, impack: true }],
+      submission: []
+    });
+  }
+};
+function detectFileFormatFromContent(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return "json";
+  }
+  return "markdown";
+}
+function extractJsonFromMarkdown(markdown) {
+  const codeBlockRegex = /```(?:json)?\s*\n([\s\S]*?)```/g;
+  let match;
+  let lastMatch = null;
+  while ((match = codeBlockRegex.exec(markdown)) !== null) {
+    const jsonContent = match[1].trim();
+    if (jsonContent.startsWith("{") || jsonContent.startsWith("[")) {
+      const beforeMatch = markdown.substring(0, match.index);
+      const lineOffset = (beforeMatch.match(/\n/g) || []).length + 1;
+      lastMatch = { json: jsonContent, lineOffset };
+    }
+  }
+  return lastMatch;
+}
+function parseTableFromMarkdown(section) {
+  const jsonMatch = section.match(/```(?:json)?\s*\n([\s\S]*?)```/);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[1]);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  const tableRows = section.match(/\|[^\n]+\|/g);
+  if (tableRows && tableRows.length > 2) {
+    return tableRows.slice(2).map((row) => {
+      const cells = row.split("|").filter((c) => c.trim()).map((c) => c.trim());
+      const valueTypeCell = cells[2];
+      let value_type;
+      const numericMatch = valueTypeCell.match(/\d+/);
+      if (numericMatch) {
+        value_type = parseInt(numericMatch[0], 10);
+      } else {
+        const typeNameMatch = valueTypeCell.match(/^([A-Za-z]+)/);
+        if (typeNameMatch) {
+          value_type = typeNameMatch[1];
+        } else {
+          throw new Error(
+            `Invalid value_type in table row: "${valueTypeCell}". Expected a number (0-19) or type name (e.g., "U64", "Address")`
+          );
+        }
+      }
+      return {
+        identifier: parseInt(cells[0], 10),
+        b_submission: cells[1].toLowerCase() === "true",
+        value_type,
+        value: cells[3] === "-" ? void 0 : cells[3],
+        name: cells[4] === "-" ? void 0 : cells[4]
+      };
+    });
+  }
+  return void 0;
+}
+function parseRelyFromMarkdown(section) {
+  const logicMatch = section.match(/\*\*Logic:\*\*\s*(AND|OR)/i);
+  const guardListMatches = section.match(/^\s*[-*]\s*(\S+)$/gm);
+  if (logicMatch || guardListMatches) {
+    return {
+      logic_or: logicMatch ? logicMatch[1].toUpperCase() === "OR" : false,
+      guards: guardListMatches ? guardListMatches.map(
+        (g) => g.replace(/^\s*[-*]\s*/, "").trim()
+      ) : []
+    };
+  }
+  return void 0;
+}
+function parseGuardFromMarkdown(content) {
+  const errors = [];
+  const result = {};
+  const jsonMatch = extractJsonFromMarkdown(content);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(
+        jsonMatch.json
+      );
+      Object.assign(result, parsed);
+    } catch (e) {
+      errors.push({
+        message: `Failed to parse JSON from code block: ${e.message}`,
+        path: "/",
+        line: jsonMatch.lineOffset
+      });
+    }
+  }
+  if (!result.description) {
+    const descMatch = content.match(
+      /(?:^|\n)#+\s*(?:Description|Description|Description)[^\n]*\n+([^\n#]+)/i
+    );
+    if (descMatch) {
+      result.description = descMatch[1].trim();
+    }
+  }
+  if (!result.table) {
+    const tableMatch = content.match(
+      /(?:^|\n)#+\s*(?:Table|Data Table|数据表)[^\n]*\n+([\s\S]*?)(?=(?:\n#+|$))/i
+    );
+    if (tableMatch) {
+      const table = parseTableFromMarkdown(tableMatch[1]);
+      if (table) {
+        result.table = table;
+      }
+    }
+  }
+  if (!result.root) {
+    const rootMatch = content.match(
+      /(?:^|\n)#+\s*(?:Root|根节点)[^\n]*\n+([\s\S]*?)(?=(?:\n#+|$))/i
+    );
+    if (rootMatch) {
+      const rootSection = rootMatch[1];
+      const rootJsonMatch = rootSection.match(
+        /```(?:json)?\s*\n([\s\S]*?)```/
+      );
+      if (rootJsonMatch) {
+        try {
+          result.root = JSON.parse(rootJsonMatch[1]);
+        } catch (e) {
+          errors.push({
+            message: `Failed to parse root JSON: ${e.message}`,
+            path: "/root"
+          });
+        }
+      }
+    }
+  }
+  if (!result.rely) {
+    const relyMatch = content.match(
+      /(?:^|\n)#+\s*(?:Rely|Dependencies|依赖)[^\n]*\n+([\s\S]*?)(?=(?:\n#+|$))/i
+    );
+    if (relyMatch) {
+      const rely = parseRelyFromMarkdown(relyMatch[1]);
+      if (rely) {
+        result.rely = rely;
+      }
+    }
+  }
+  if (!result.root) {
+    errors.push({
+      message: "Guard root node not found in markdown file",
+      path: "/root"
+    });
+    return { success: false, errors };
+  }
+  return {
+    success: true,
+    data: result,
+    errors
+  };
+}
+function parseGuardFile(content, format) {
+  const detectedFormat = format ?? detectFileFormatFromContent(content);
+  if (detectedFormat === "json") {
+    try {
+      const parsed = JSON.parse(content);
+      if (!parsed.root) {
+        return {
+          success: false,
+          errors: [
+            {
+              message: "Missing required field: root",
+              path: "/root"
+            }
+          ]
+        };
+      }
+      return { success: true, data: parsed, errors: [] };
+    } catch (e) {
+      return {
+        success: false,
+        errors: [
+          {
+            message: `JSON parse error: ${e.message}`,
+            path: "/"
+          }
+        ]
+      };
+    }
+  }
+  return parseGuardFromMarkdown(content);
+}
+function validateGuardNode(node) {
+  const errors = [];
+  if (!node || typeof node !== "object") {
+    errors.push({ message: "GuardNode must be an object", path: "/" });
+    return { success: false, errors };
+  }
+  const n = node;
+  if (!n.type || typeof n.type !== "string") {
+    errors.push({
+      message: "GuardNode must have a 'type' property",
+      path: "/type"
+    });
+    return { success: false, errors };
+  }
+  const validTypes = [
+    "identifier",
+    "query",
+    "context",
+    "logic_not",
+    "logic_and",
+    "logic_or",
+    "logic_equal",
+    "logic_as_u256_greater_or_equal",
+    "logic_as_u256_lesser_or_equal",
+    "logic_as_u256_greater",
+    "logic_as_u256_lesser",
+    "logic_as_u256_equal",
+    "logic_string_contains",
+    "logic_string_nocase_contains",
+    "logic_string_nocase_equal",
+    "calc_number_add",
+    "calc_number_subtract",
+    "calc_number_multiply",
+    "calc_number_divide",
+    "calc_number_mod",
+    "calc_string_length",
+    "calc_string_nocase_contains",
+    "calc_string_nocase_equal",
+    "calc_string_contains",
+    "calc_string_indexof",
+    "calc_string_nocase_indexof",
+    "convert_number_address",
+    "convert_address_number",
+    "convert_number_string",
+    "convert_string_number",
+    "convert_safe_u8",
+    "convert_safe_u16",
+    "convert_safe_u32",
+    "convert_safe_u64",
+    "convert_safe_u128",
+    "convert_safe_u256",
+    "value_type",
+    "vec_length",
+    "vec_contains_bool",
+    "vec_contains_address",
+    "vec_contains_string",
+    "vec_contains_string_nocase",
+    "vec_contains_number",
+    "vec_indexof_bool",
+    "vec_indexof_address",
+    "vec_indexof_string",
+    "vec_indexof_string_nocase",
+    "vec_indexof_number"
+  ];
+  if (!validTypes.includes(n.type)) {
+    errors.push({
+      message: `Invalid GuardNode type: ${n.type}`,
+      path: "/type"
+    });
+  }
+  return { success: errors.length === 0, errors };
+}
+function formatGuardParseErrors(errors) {
+  return errors.map((e) => {
+    let msg = `Path: ${e.path}`;
+    if (e.line !== void 0 && e.column !== void 0) {
+      msg += ` (line ${e.line}, column ${e.column})`;
+    }
+    msg += `
+  Error: ${e.message}`;
+    return msg;
+  }).join("\n\n");
+}