wowok 2.1.9 → 2.1.12

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

@@ -1,33 +1,11 @@
-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";
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+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 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 { 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";
@@ -36,1167 +14,1135 @@ 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}`;
+// ================================================
+export 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");
+export class CallGuard extends CallBase {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
     }
-    if (!this.data.root) {
-      W_ERROR(WErrors.InvalidParam, "root is empty");
+    async call(env) {
+        await this.prepare(env);
+        return await this.exec(env);
     }
-    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)
-      );
+    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);
+            // 查找原始数组中undefined值的索引
+            const undefinedIndex = relyGuards.findIndex((v) => v === undefined);
+            if (undefinedIndex !== -1) {
+                W_ERROR(WErrors.InvalidParam, `rely.guards invalid: guard at index ${undefinedIndex} not found`);
+            }
+            reliesAdd(tx, guard, relyGuards.filter((v) => v !== undefined));
+        }
+        await this.new_with_mark(env, tx, ObjectType.Guard, create(tx, guard), this.data?.namedNew);
     }
-    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);
+export const newGuard = async (tx, description, table, root) => {
+    if (!isValidDescription(description)) {
+        W_ERROR(WErrors.IsValidDescription, `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
+    }
+    // check const
+    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 === undefined || 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(", ")}`);
+    }
+    // check root
+    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;
+    }
+    /*console.log(
+        "Input (decimal):",
+        Array.from(input)
+            .map((byte) => byte.toString(10))
+            .join(" "),
+    );*/
+    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];
+        // 转换 value_type 为枚举值（支持字符串输入）
+        const valueType = parseValueType(item.value_type);
+        // 根据b_submission的值计算bcsValue
+        let bcsValue;
+        if (item.b_submission) {
+            bcsValue = new Uint8Array(1);
+            bcsValue[0] = valueType;
+        }
+        else {
+            if (item.value === undefined || 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),
+            ],
+        }));
     }
-    tableItems.push(
-      tx.moveCall({
-        target: guardFn("table_item"),
+    return tx.moveCall({
+        target: guardFn("new"),
         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))
-    ]
-  });
+            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()
-    ]
-  });
+export 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`);
+export 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}`);
     }
-    tx.moveCall({
-      target: guardFn("relies_add"),
-      arguments: [
-        toTxObject(tx, guard),
-        toTxObject(tx, g),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ]
+    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()
-      ]
+export 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()]
-  });
+export 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)]
-  });
+// set the logic(and/or) of the guard; default is and
+export 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
-          );
+    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;
         }
-      } 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})`
-          );
+        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;
         }
-        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;
+        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;
         }
-        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;
+        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);
+            //@ 第一个节点是vec类型，后面的节点是元素类型
+            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;
         }
-        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;
+            W_ERROR(WErrors.InvalidParam, "node:" + JSON.stringify(node));
     }
-    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 <=  
+    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());
+				${JSON.stringify(parameters)}`);
+    }
+    //@ 和query一样，栈顶是第一个参数
+    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()); // TYPE
+    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());
+    await buildNode(parameter, required_type, table, output);
+    output.push(bcs.U8.serialize(op_code).toBytes()); // TYPE
 };
-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}`
-    );
-  }
+/**
+ * Query Guard object data and export to JSON or Markdown file
+ * @param guard - Guard object ID or name
+ * @param file_path - Output file path
+ * @param format - Output format: "json" or "markdown"
+ * @param network - Network entrypoint
+ * @throws Error if query fails or file write fails
+ */
+export const guard2file = async (guard, file_path, format = "json", network) => {
+    // Query Guard object
+    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;
+    }
+    // Prepare output content based on format
+    let content;
+    if (format === "json") {
+        content = generateGuardJson(guardObj);
+    }
+    else {
+        content = generateGuardMarkdown(guardObj);
+    }
+    // Write to file
+    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}`);
+    }
 };
+/**
+ * Generate JSON format Guard definition with comments
+ */
 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 output = {};
+    // Description
+    if (guardObj.description) {
+        output.description = guardObj.description;
+    }
+    // Table
+    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,
+        }));
+    }
+    // Root node - use guardObj.root directly (already parsed tree structure)
+    if (guardObj.root) {
+        output.root = guardObj.root;
+    }
+    // Rely (dependencies)
+    if (guardObj.relies && guardObj.relies.length > 0) {
+        output.rely = {
+            guards: guardObj.relies,
+            logic_or: !guardObj.relies_logic_and,
+        };
+    }
+    return JSON.stringify(output, null, 2);
 };
+/**
+ * Generate Markdown format Guard definition with comments
+ */
 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("```");
+    const lines = [];
+    // Header
+    lines.push(`# Guard Definition`);
     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(`**Object ID:** ${guardObj.object}`);
+    lines.push("");
+    // Summary
+    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("");
-  }
-  if (guardObj.relies && guardObj.relies.length > 0) {
-    lines.push("## Rely (Dependencies)");
+    // Description
+    lines.push("## Description");
     lines.push("");
-    lines.push(`**Logic:** ${guardObj.relies_logic_and ? "AND" : "OR"}`);
+    lines.push(guardObj.description || "");
     lines.push("");
-    lines.push("**Dependent Guards:**");
-    for (const rely of guardObj.relies) {
-      lines.push(`- ${rely}`);
+    // Table
+    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("");
+    // Root node - use guardObj.root directly (already parsed tree structure)
+    lines.push("## Root (Computational Tree)");
+    lines.push("");
+    lines.push("The root node MUST return a Bool value (pass/fail).");
     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");
+    if (guardObj.root) {
+        lines.push("```json");
+        lines.push(JSON.stringify(guardObj.root, null, 2));
+        lines.push("```");
+        lines.push("");
+        // Add node comments
+        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("");
+    }
+    // Rely
+    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");
 };
+/**
+ * Format value for markdown display
+ */
 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) + "...";
+    if (value === undefined || value === null) {
+        return "-";
     }
-    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)]`;
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
     }
-    return `[${value.join(", ")}]`;
-  }
-  if (typeof value === "object") {
-    return "{...}";
-  }
-  return String(value);
+    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) {
+/**
+ * Generate comments for Guard nodes
+ */
+export const generateNodeComments = (node, comments = []) => {
+    if (!node)
+        return comments;
+    // Add comment for this node
+    if (node.type === "query") {
+        const queryId = typeof node.query === "number" ? node.query : undefined;
+        if (queryId !== undefined) {
+            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: `query(${node.query})`,
-          description: `${queryInfo.name}: ${queryInfo.description}`
+            type: node.type,
+            description: `Logic operation: ${node.type.replace(/_/g, " ")}`,
         });
-      }
     }
-  } 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);
+    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, " ")}`,
+        });
+    }
+    // Recursively process child nodes
+    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 ("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 ("nodeRight" in node && node.nodeRight) {
+        generateNodeComments(node.nodeRight, comments);
     }
-  }
-  if ("nodeLeft" in node && node.nodeLeft) {
-    generateNodeComments(node.nodeLeft, comments);
-  }
-  if ("nodeRight" in node && node.nodeRight) {
-    generateNodeComments(node.nodeRight, comments);
-  }
-  return comments;
+    return comments;
 };
+/**
+ * Convert ValueType enum to string representation
+ */
 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 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);
+export 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: [],
+        });
     }
-  } else {
-    return await verify_guard(env, {
-      type: "submission",
-      guard: [{ object: guard, impack: true }],
-      submission: []
-    });
-  }
 };
+/**
+ * Detect file format from content or extension
+ */
 function detectFileFormatFromContent(text) {
-  const trimmed = text.trim();
-  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-    return "json";
-  }
-  return "markdown";
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        return "json";
+    }
+    return "markdown";
 }
+/**
+ * Extract JSON from markdown code blocks
+ */
 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 };
+    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 };
+            // Continue to find the last JSON block (most complete one)
+        }
     }
-  }
-  return lastMatch;
+    return lastMatch;
 }
+/**
+ * Parse table from markdown section
+ * First tries JSON code block, then falls back to markdown table
+ */
 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")`
-          );
+    // Try JSON code block first
+    const jsonMatch = section.match(/```(?:json)?\s*\n([\s\S]*?)```/);
+    if (jsonMatch) {
+        try {
+            const parsed = JSON.parse(jsonMatch[1]);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
         }
-      }
-      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;
+        catch {
+            // JSON parse failed, continue to table parsing
+        }
+    }
+    // Fallback to markdown table
+    const tableRows = section.match(/\|[^\n]+\|/g);
+    if (tableRows && tableRows.length > 2) {
+        // Skip header and separator rows
+        return tableRows.slice(2).map((row) => {
+            const cells = row
+                .split("|")
+                .filter((c) => c.trim())
+                .map((c) => c.trim());
+            // Parse value_type - can be number (6) or string ("U64" or "U64 (6)")
+            const valueTypeCell = cells[2];
+            let value_type;
+            // Try to parse as number first
+            const numericMatch = valueTypeCell.match(/\d+/);
+            if (numericMatch) {
+                value_type = parseInt(numericMatch[0], 10);
+            }
+            else {
+                // Try to extract type name (e.g., "U64" from "U64" or "U64 (6)")
+                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] === "-" ? undefined : cells[3],
+                name: cells[4] === "-" ? undefined : cells[4],
+            };
+        });
+    }
+    return undefined;
 }
+/**
+ * Parse rely from markdown section
+ */
 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;
+    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 undefined;
 }
-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
-      });
+/**
+ * Parse Guard definition from markdown content
+ * Unified parsing logic shared between SDK and MCP
+ */
+export function parseGuardFromMarkdown(content) {
+    const errors = [];
+    const result = {};
+    // Try to extract full JSON from code blocks first
+    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();
+    // Parse description section (if not already from JSON)
+    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;
-      }
+    // Parse table section (if not already from JSON)
+    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"
-          });
+    // Parse root section (if not already from JSON)
+    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;
-      }
+    // Parse rely section (if not already from JSON)
+    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
-  };
+    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"
+/**
+ * Parse Guard definition from file content
+ * Supports both JSON and Markdown formats
+ * Unified parsing logic shared between SDK and MCP
+ */
+export 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 { success: true, data: parsed, errors: [] };
+        }
+        catch (e) {
+            return {
+                success: false,
+                errors: [
+                    {
+                        message: `JSON parse error: ${e.message}`,
+                        path: "/",
+                    },
+                ],
+            };
+        }
     }
-  }
-  return parseGuardFromMarkdown(content);
+    // Markdown format
+    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})`;
+/**
+ * Validate GuardNode structure
+ * Basic validation without Zod dependency
+ */
+export function validateGuardNode(node) {
+    const errors = [];
+    if (!node || typeof node !== "object") {
+        errors.push({ message: "GuardNode must be an object", path: "/" });
+        return { success: false, errors };
     }
-    msg += `
-  Error: ${e.message}`;
-    return msg;
-  }).join("\n\n");
+    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 };
+    }
+    // Basic type validation based on node type
+    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 };
 }
-export {
-  CallGuard,
-  create,
-  formatGuardParseErrors,
-  gen_passport,
-  guard2file,
-  guardFn,
-  newGuard,
-  parseGuardFile,
-  parseGuardFromMarkdown,
-  reliesAdd,
-  reliesClear,
-  reliesLogic,
-  reliesRemove,
-  validateGuardNode
-};
+/**
+ * Format parse errors for display
+ */
+export function formatGuardParseErrors(errors) {
+    return errors
+        .map((e) => {
+        let msg = `Path: ${e.path}`;
+        if (e.line !== undefined && e.column !== undefined) {
+            msg += ` (line ${e.line}, column ${e.column})`;
+        }
+        msg += `\n  Error: ${e.message}`;
+        return msg;
+    })
+        .join("\n\n");
+}
+//# sourceMappingURL=guard.js.map