wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1202 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  toTxObject,
+  toTxString,
+  isValidDescription,
+  MAX_DESCRIPTION_LENGTH,
+  isValidU8,
+  isValidName,
+  ValueType,
+  parseValueType,
+  OperatorType,
+  ContextType,
+  isWitnessType,
+  PackageAddress,
+  ObjectType,
+  MAX_INPUT_SIZE,
+  MAX_DEPENDED_COUNT,
+  MAX_MULTI_OPERANDS
+} from "../common.js";
+import _ from "lodash";
+import { W_ERROR, WErrors } from "../exception.js";
+import { CallBase } from "./base.js";
+import { LocalMark } from "../local/local.js";
+import {
+  WitnessSourceType,
+  WitnessTargetType,
+  query_objects
+} from "../query/object.js";
+import { bcs } from "../../bcs/index.js";
+import { valueToBcsBytes } from "../util.js";
+import { getGuardQueryInfo, GUARDQUERY } from "./guard-ins.js";
+import { checkType, resolveCallEnv } from "./util.js";
+import { isValidWowAddress } from "../../utils/sui-types.js";
+import { get_guardSubmissions, verify_guard } from "./passport.js";
+import { writeFileSync } from "fs";
+import { resolve } from "path";
+function guardFn(name) {
+  return `${PackageAddress}::guard::${name}`;
+}
+class CallGuard extends 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) {
+      W_ERROR(WErrors.InvalidParam, "table is empty");
+    }
+    if (!this.data.root) {
+      W_ERROR(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 LocalMark.Instance().get_many_address(
+        this.data.rely.guards
+      );
+      const undefinedIndex = relyGuards.findIndex((v) => v === void 0);
+      if (undefinedIndex !== -1) {
+        W_ERROR(
+          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,
+      ObjectType.Guard,
+      create(tx, guard),
+      this.data?.namedNew
+    );
+  }
+}
+const newGuard = async (tx, description, table, root) => {
+  if (!isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  for (let i = 0; i < table.length; i++) {
+    const v = table[i];
+    if (!isValidU8(v.identifier))
+      W_ERROR(
+        WErrors.InvalidParam,
+        `table.identifier ${v.identifier} invalid`
+      );
+    if (!v.b_submission && (v.value === void 0 || v.value === null))
+      W_ERROR(
+        WErrors.InvalidParam,
+        `table.value ${v.value} with identifier ${v.identifier} invalid`
+      );
+    if (!isValidName(v.name)) W_ERROR(WErrors.InvalidParam, "table.name");
+  }
+  const grouped = _.groupBy(table, "identifier");
+  const duplicates = Object.keys(grouped).filter(
+    (key) => grouped[key].length > 1
+  );
+  if (duplicates.length > 0) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `table.identifier duplicates: ${duplicates.join(", ")}`
+    );
+  }
+  var output = [];
+  await buildNode(root, 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 > MAX_INPUT_SIZE) {
+    W_ERROR(
+      WErrors.NewGuardCheckFailed,
+      `Input size exceeds maximum limit ${MAX_INPUT_SIZE}`
+    );
+  }
+  if (input.length === 0) {
+    W_ERROR(WErrors.NewGuardCheckFailed, `Input cannot be empty`);
+  }
+  const tableItems = [];
+  for (let i = 0; i < table.length; i++) {
+    const item = table[i];
+    const valueType = 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) {
+        W_ERROR(
+          WErrors.NewGuardCheckFailed,
+          `Table item value is required when b_submission is false`
+        );
+      }
+      bcsValue = await 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)),
+          toTxString(tx, item.name)
+        ]
+      })
+    );
+  }
+  return tx.moveCall({
+    target: guardFn("new"),
+    arguments: [
+      toTxString(tx, description),
+      tx.makeMoveVec({
+        elements: tableItems,
+        type: `${PackageAddress}::guard::TableItem`
+      }),
+      tx.pure.vector("u8", Array.from(input))
+    ]
+  });
+};
+function create(tx, guard) {
+  return tx.moveCall({
+    target: guardFn("create"),
+    arguments: [
+      toTxObject(tx, guard),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function reliesAdd(tx, guard, rely_guards) {
+  const guards = _.uniq(rely_guards);
+  if (guards.length > MAX_DEPENDED_COUNT) {
+    W_ERROR(
+      WErrors.NewGuardCheckFailed,
+      `Relies count exceeds maximum limit ${MAX_DEPENDED_COUNT}`
+    );
+  }
+  guards.forEach((g) => {
+    if (g === guard) {
+      W_ERROR(WErrors.NewGuardCheckFailed, `Guard cannot rely on itself`);
+    }
+    tx.moveCall({
+      target: guardFn("relies_add"),
+      arguments: [
+        toTxObject(tx, guard),
+        toTxObject(tx, g),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  });
+}
+function reliesRemove(tx, guard, rely_guards) {
+  const guards = _.uniq(rely_guards);
+  if (guards.length > MAX_DEPENDED_COUNT) {
+    W_ERROR(
+      WErrors.NewGuardCheckFailed,
+      `Relies count exceeds maximum limit ${MAX_DEPENDED_COUNT}`
+    );
+  }
+  guards.forEach((g) => {
+    tx.moveCall({
+      target: guardFn("relies_remove"),
+      arguments: [
+        toTxObject(tx, guard),
+        toTxObject(tx, g),
+        tx.object.mutRegistrar()
+      ]
+    });
+  });
+}
+function reliesClear(tx, guard) {
+  tx.moveCall({
+    target: guardFn("relies_clear"),
+    arguments: [toTxObject(tx, guard), tx.object.mutRegistrar()]
+  });
+}
+function reliesLogic(tx, guard, logic_and) {
+  tx.moveCall({
+    target: guardFn("relies_logic_and"),
+    arguments: [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 = parseValueType(f.value_type);
+        checkType(fValueType, type_required, node);
+        output.push(
+          bcs.U8.serialize(ContextType.TypeConstant).toBytes()
+        );
+        output.push(bcs.U8.serialize(node.identifier).toBytes());
+      } else {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "node identifier - " + JSON.stringify(node)
+        );
+      }
+      break;
+    }
+    case "query": {
+      const q = getGuardQueryInfo(node.query);
+      if (!q) {
+        W_ERROR(WErrors.InvalidParam, `query not found: ${node.query}`);
+      }
+      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 {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "node query parameters length not match - " + JSON.stringify(node)
+        );
+      }
+      const tableItem = table.find(
+        (v) => v.identifier === node.object.identifier
+      );
+      if (!tableItem) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "node object from identifier - " + JSON.stringify(node)
+        );
+      }
+      const tableItemValueType = parseValueType(tableItem.value_type);
+      if (tableItemValueType !== ValueType.Address) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `object to query must be address in table ${tableItem}. ${node.object}`
+        );
+      }
+      output.push(bcs.U8.serialize(OperatorType.TypeQuery).toBytes());
+      if (isWitnessType(node.object.convert_witness)) {
+        const target = WitnessTargetType(node.object.convert_witness);
+        if (target !== q.objectType) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `witness object type(${target}) not consistent with query object type(${q.objectType})`
+          );
+        }
+        const source = WitnessSourceType(node.object.convert_witness);
+        if (tableItem.object_type) {
+          if (tableItem.object_type !== source) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `witness object type(${source}) not consistent with query object type(${tableItem.object_type})`
+            );
+          }
+        } else {
+          tableItem.object_type = source;
+        }
+        output.push(
+          bcs.U8.serialize(node.object.convert_witness).toBytes()
+        );
+      } else {
+        if (tableItem?.object_type) {
+          if (tableItem.object_type !== q.objectType) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `witness object type(${q.objectType}) not consistent with query object type(${tableItem.object_type})`
+            );
+          }
+        } else {
+          tableItem.object_type = q.objectType;
+        }
+        output.push(
+          bcs.U8.serialize(ContextType.TypeConstant).toBytes()
+        );
+      }
+      output.push(bcs.U8.serialize(node.object.identifier).toBytes());
+      output.push(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: OperatorType.TypeLogicAsU256GreaterEqual,
+        logic_as_u256_lesser_or_equal: OperatorType.TypeLogicAsU256LesserEqual,
+        logic_as_u256_equal: OperatorType.TypeLogicAsU256Equal,
+        logic_as_u256_greater: OperatorType.TypeLogicAsU256Greater,
+        logic_as_u256_lesser: OperatorType.TypeLogicAsU256Lesser,
+        logic_equal: OperatorType.TypeLogicEqual,
+        logic_and: OperatorType.TypeLogicAnd,
+        logic_or: OperatorType.TypeLogicOr,
+        logic_string_contains: OperatorType.TypeStringContains,
+        logic_string_nocase_contains: OperatorType.TypeStringNocaseContains,
+        logic_string_nocase_equal: OperatorType.TypeStringNocaseEqual,
+        calc_number_add: OperatorType.TypeNumberAdd,
+        calc_number_subtract: OperatorType.TypeNumberSubtract,
+        calc_number_multiply: OperatorType.TypeNumberMultiply,
+        calc_number_divide: OperatorType.TypeNumberDivide,
+        calc_number_mod: OperatorType.TypeNumberMod,
+        calc_string_nocase_contains: OperatorType.TypeStringNocaseContains,
+        calc_string_nocase_equal: OperatorType.TypeStringNocaseEqual,
+        calc_string_contains: 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: ValueType.Bool,
+        logic_or: ValueType.Bool,
+        logic_string_contains: ValueType.String,
+        logic_string_nocase_contains: ValueType.String,
+        logic_string_nocase_equal: 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: ValueType.String,
+        calc_string_nocase_equal: ValueType.String,
+        calc_string_contains: ValueType.String
+      };
+      const returnTypeMap = {
+        logic_as_u256_greater_or_equal: ValueType.Bool,
+        logic_as_u256_lesser_or_equal: ValueType.Bool,
+        logic_as_u256_equal: ValueType.Bool,
+        logic_as_u256_greater: ValueType.Bool,
+        logic_as_u256_lesser: ValueType.Bool,
+        logic_equal: ValueType.Bool,
+        logic_and: ValueType.Bool,
+        logic_or: ValueType.Bool,
+        logic_string_contains: ValueType.Bool,
+        logic_string_nocase_contains: ValueType.Bool,
+        logic_string_nocase_equal: ValueType.Bool,
+        calc_number_add: ValueType.U256,
+        calc_number_subtract: ValueType.U256,
+        calc_number_multiply: ValueType.U256,
+        calc_number_divide: ValueType.U256,
+        calc_number_mod: ValueType.U256,
+        calc_string_nocase_contains: ValueType.Bool,
+        calc_string_nocase_equal: ValueType.Bool,
+        calc_string_contains: ValueType.Bool
+      };
+      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: OperatorType.TypedValueVecContains_Bool,
+        vec_contains_address: OperatorType.TypedValueVecContains_Address,
+        vec_contains_string: OperatorType.TypedValueVecContains_String,
+        vec_contains_string_nocase: OperatorType.TypedValueVecContains_StringNoCase,
+        vec_contains_number: OperatorType.TypedValueVecContains_Number
+      };
+      const vecTypeMap = {
+        vec_contains_bool: ValueType.VecBool,
+        vec_contains_address: ValueType.VecAddress,
+        vec_contains_string: ValueType.VecString,
+        vec_contains_string_nocase: ValueType.VecString,
+        vec_contains_number: "vec_number"
+      };
+      const elemTypeMap = {
+        vec_contains_bool: ValueType.Bool,
+        vec_contains_address: ValueType.Address,
+        vec_contains_string: ValueType.String,
+        vec_contains_string_nocase: ValueType.String,
+        vec_contains_number: "number"
+      };
+      checkType(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(bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+      output.push(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: OperatorType.TypeLogicNot,
+        calc_string_length: OperatorType.TypeStringLength,
+        convert_number_address: OperatorType.TypeNumberAddress,
+        convert_address_number: OperatorType.TypeAddressNumber,
+        convert_number_string: OperatorType.TypeNumberString,
+        convert_string_number: OperatorType.TypeStringNumber,
+        //convert_string_lowercase: OperatorType.TypeStringLowercase,
+        convert_safe_u8: OperatorType.TypeSafeU8,
+        convert_safe_u16: OperatorType.TypeSafeU16,
+        convert_safe_u32: OperatorType.TypeSafeU32,
+        convert_safe_u64: OperatorType.TypeSafeU64,
+        convert_safe_u128: OperatorType.TypeSafeU128,
+        convert_safe_u256: OperatorType.TypeSafeU256,
+        value_type: OperatorType.TypedValueType,
+        vec_length: OperatorType.TypedValueVecLength
+      };
+      const requiredTypeMap = {
+        logic_not: ValueType.Bool,
+        calc_string_length: ValueType.String,
+        convert_number_address: "number",
+        convert_address_number: ValueType.Address,
+        convert_number_string: "number",
+        convert_string_number: 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: ValueType.Bool,
+        calc_string_length: ValueType.U64,
+        convert_number_address: ValueType.Address,
+        convert_address_number: ValueType.U256,
+        convert_number_string: ValueType.String,
+        convert_string_number: ValueType.U256,
+        convert_safe_u8: ValueType.U8,
+        convert_safe_u16: ValueType.U16,
+        convert_safe_u32: ValueType.U32,
+        convert_safe_u64: ValueType.U64,
+        convert_safe_u128: ValueType.U128,
+        convert_safe_u256: ValueType.U256,
+        value_type: ValueType.U8,
+        vec_length: ValueType.U64
+      };
+      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: OperatorType.TypeStringIndexof,
+        calc_string_nocase_indexof: OperatorType.TypeStringNocaseIndexof
+      };
+      checkType(ValueType.U64, type_required, node);
+      await buildNode(node.nodeRight, ValueType.String, table, output);
+      await buildNode(node.nodeLeft, ValueType.String, table, output);
+      output.push(bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+      output.push(
+        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: OperatorType.TypedValueVecIndexOf_Bool,
+        vec_indexof_address: OperatorType.TypedValueVecIndexOf_Address,
+        vec_indexof_string: OperatorType.TypedValueVecIndexOf_String,
+        vec_indexof_string_nocase: OperatorType.TypedValueVecIndexOf_StringNoCase,
+        vec_indexof_number: OperatorType.TypedValueVecIndexOf_Number
+      };
+      const rightTypeMap = {
+        vec_indexof_bool: ValueType.Bool,
+        vec_indexof_address: ValueType.Address,
+        vec_indexof_string: ValueType.String,
+        vec_indexof_string_nocase: ValueType.String,
+        vec_indexof_number: "number"
+      };
+      const leftTypeMap = {
+        vec_indexof_bool: ValueType.VecBool,
+        vec_indexof_address: ValueType.VecAddress,
+        vec_indexof_string: ValueType.VecString,
+        vec_indexof_string_nocase: ValueType.VecString,
+        vec_indexof_number: "vec_number"
+      };
+      checkType(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(bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+      output.push(
+        bcs.U8.serialize(node.order === "forward" ? 0 : 1).toBytes()
+      );
+      break;
+    }
+    case "context": {
+      let contextValue;
+      switch (node.context) {
+        case "Signer":
+          contextValue = ContextType.TypeSigner;
+          break;
+        case "Clock":
+          contextValue = ContextType.TypeClock;
+          break;
+        case "Guard":
+          contextValue = ContextType.TypeGuard;
+          break;
+        default:
+          W_ERROR(
+            WErrors.InvalidParam,
+            "Invalid context type: " + node.context
+          );
+      }
+      output.push(bcs.U8.serialize(contextValue).toBytes());
+      checkType(ValueType.Address, type_required, node);
+      break;
+    }
+    default:
+      W_ERROR(WErrors.InvalidParam, "node:" + JSON.stringify(node));
+  }
+};
+const multi_operand_op = async (op_code, parameters, required_type, table, output) => {
+  if (parameters.length < 2 || parameters.length > MAX_MULTI_OPERANDS) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `op ${op_code} parameters length must >= 2 and <=  
+				${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(bcs.U8.serialize(op_code).toBytes());
+  output.push(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(bcs.U8.serialize(op_code).toBytes());
+};
+const guard2file = async (guard, file_path, format = "json", network) => {
+  const queryResult = await query_objects({
+    objects: [guard],
+    network
+  });
+  const objects = queryResult.objects;
+  if (!objects || objects.length === 0 || objects[0].type !== "Guard") {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `guard2file: Guard object not found: ${guard}`
+    );
+    return;
+  }
+  const guardObj = objects[0];
+  if (!guardObj) {
+    W_ERROR(
+      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 = resolve(file_path);
+    writeFileSync(resolvedPath, content, "utf-8");
+  } catch (e) {
+    W_ERROR(
+      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("## 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 = 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("");
+  }
+  lines.push("## Guard Instructions Reference");
+  lines.push("");
+  lines.push("Use these instructions in query nodes:");
+  lines.push("");
+  lines.push("| ID | Name | Object Type | Return Type | Description |");
+  lines.push("|----|------|-------------|-------------|-------------|");
+  for (const query of GUARDQUERY.slice(0, 20)) {
+    lines.push(
+      `| ${query.id} | ${query.name} | ${query.objectType} | ${valueTypeToString(query.return)} | ${query.description} |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    "*For complete list, use `wowok_buildin_info` with query='guard instructions'*"
+  );
+  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 = 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 = {
+    [ValueType.Bool]: "Bool",
+    [ValueType.Address]: "Address",
+    [ValueType.String]: "String",
+    [ValueType.U8]: "U8",
+    [ValueType.U16]: "U16",
+    [ValueType.U32]: "U32",
+    [ValueType.U64]: "U64",
+    [ValueType.U128]: "U128",
+    [ValueType.U256]: "U256",
+    [ValueType.VecBool]: "VecBool",
+    [ValueType.VecAddress]: "VecAddress",
+    [ValueType.VecString]: "VecString",
+    [ValueType.VecU8]: "VecU8",
+    [ValueType.VecU16]: "VecU16",
+    [ValueType.VecU32]: "VecU32",
+    [ValueType.VecU64]: "VecU64",
+    [ValueType.VecU128]: "VecU128",
+    [ValueType.VecU256]: "VecU256",
+    [ValueType.VecVecU8]: "VecVecU8",
+    [ValueType.Value]: "Value"
+  };
+  return typeMap[valueType] || `Unknown(${valueType})`;
+};
+const gen_passport = async (env, guard, info) => {
+  if (!isValidWowAddress(guard)) {
+    W_ERROR(WErrors.InvalidParam, "guard invalid: guard empty");
+  }
+  await resolveCallEnv(env);
+  const s = await get_guardSubmissions(env, [guard]);
+  if (s.submission.length > 0) {
+    if (!info) {
+      return {
+        type: "submission",
+        guard: s.guard,
+        submission: s.submission
+      };
+    } else {
+      return await verify_guard(env, info);
+    }
+  } else {
+    return await 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");
+}
+export {
+  CallGuard,
+  create,
+  formatGuardParseErrors,
+  gen_passport,
+  guard2file,
+  guardFn,
+  newGuard,
+  parseGuardFile,
+  parseGuardFromMarkdown,
+  reliesAdd,
+  reliesClear,
+  reliesLogic,
+  reliesRemove,
+  validateGuardNode
+};