wowok 2.1.13 → 2.1.16

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

@@ -1,40 +1,24 @@
-"use strict";
 // Copyright (c) Wowok.
 // SPDX-License-Identifier: Apache-2.0
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gen_passport = exports.generateNodeComments = exports.guard2file = exports.newGuard = exports.CallGuard = void 0;
-exports.guardFn = guardFn;
-exports.create = create;
-exports.reliesAdd = reliesAdd;
-exports.reliesRemove = reliesRemove;
-exports.reliesClear = reliesClear;
-exports.reliesLogic = reliesLogic;
-exports.parseGuardFromMarkdown = parseGuardFromMarkdown;
-exports.parseGuardFile = parseGuardFile;
-exports.validateGuardNode = validateGuardNode;
-exports.formatGuardParseErrors = formatGuardParseErrors;
-const common_js_1 = require("../common.js");
-const lodash_1 = __importDefault(require("lodash")); // Import lodash
-const exception_js_1 = require("../exception.js");
-const base_js_1 = require("./base.js");
-const local_js_1 = require("../local/local.js");
-const object_js_1 = require("../query/object.js");
-const index_js_1 = require("../../bcs/index.js");
-const util_js_1 = require("../util.js");
-const guard_ins_js_1 = require("./guard-ins.js");
-const util_js_2 = require("./util.js");
-const sui_types_js_1 = require("../../utils/sui-types.js");
-const passport_js_1 = require("./passport.js");
-const fs_1 = require("fs");
-const path_1 = require("path");
+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 { 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 `${common_js_1.PackageAddress}::guard::${name}`;
+export function guardFn(name) {
+    return `${PackageAddress}::guard::${name}`;
 }
-class CallGuard extends base_js_1.CallBase {
+export class CallGuard extends CallBase {
     data;
     constructor(data) {
         super();
@@ -46,47 +30,46 @@ class CallGuard extends base_js_1.CallBase {
     }
     async operate(env, tx, _passport, _submission) {
         if (!this.data.table || this.data.table.length === 0) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "table is empty");
+            W_ERROR(WErrors.InvalidParam, "table is empty");
         }
         if (!this.data.root) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "root is empty");
+            W_ERROR(WErrors.InvalidParam, "root is empty");
         }
-        const guard = await (0, exports.newGuard)(tx, this.data?.description || "", this.data?.table, this.data?.root);
+        const guard = await newGuard(tx, this.data?.description || "", this.data?.table, this.data?.root);
         if (this.data?.rely != null) {
-            const relyGuards = await local_js_1.LocalMark.Instance().get_many_address(this.data.rely.guards);
+            const relyGuards = await LocalMark.Instance().get_many_address(this.data.rely.guards);
             // 查找原始数组中undefined值的索引
             const undefinedIndex = relyGuards.findIndex((v) => v === undefined);
             if (undefinedIndex !== -1) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `rely.guards invalid: guard at index ${undefinedIndex} not found`);
+                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, common_js_1.ObjectType.Guard, create(tx, guard), this.data?.namedNew);
+        await this.new_with_mark(env, tx, ObjectType.Guard, create(tx, guard), this.data?.namedNew);
     }
 }
-exports.CallGuard = CallGuard;
-const newGuard = async (tx, description, table, root) => {
-    if (!(0, common_js_1.isValidDescription)(description)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidDescription, `Description exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
+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 (!(0, common_js_1.isValidU8)(v.identifier))
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `table.identifier ${v.identifier} invalid`);
+        if (!isValidU8(v.identifier))
+            W_ERROR(WErrors.InvalidParam, `table.identifier ${v.identifier} invalid`);
         if (!v.b_submission && (v.value === undefined || v.value === null))
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `table.value ${v.value} with identifier ${v.identifier} invalid`);
-        if (!(0, common_js_1.isValidName)(v.name))
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "table.name");
+            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 = lodash_1.default.groupBy(table, "identifier");
+    const grouped = _.groupBy(table, "identifier");
     const duplicates = Object.keys(grouped).filter((key) => grouped[key].length > 1);
     if (duplicates.length > 0) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `table.identifier duplicates: ${duplicates.join(", ")}`);
+        W_ERROR(WErrors.InvalidParam, `table.identifier duplicates: ${duplicates.join(", ")}`);
     }
     // check root
     var output = [];
-    await buildNode(root, common_js_1.ValueType.Bool, table, 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;
@@ -100,17 +83,17 @@ const newGuard = async (tx, description, table, root) => {
             .map((byte) => byte.toString(10))
             .join(" "),
     );*/
-    if (input.length > common_js_1.MAX_INPUT_SIZE) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NewGuardCheckFailed, `Input size exceeds maximum limit ${common_js_1.MAX_INPUT_SIZE}`);
+    if (input.length > MAX_INPUT_SIZE) {
+        W_ERROR(WErrors.NewGuardCheckFailed, `Input size exceeds maximum limit ${MAX_INPUT_SIZE}`);
     }
     if (input.length === 0) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NewGuardCheckFailed, `Input cannot be empty`);
+        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 = (0, common_js_1.parseValueType)(item.value_type);
+        const valueType = parseValueType(item.value_type);
         // 根据b_submission的值计算bcsValue
         let bcsValue;
         if (item.b_submission) {
@@ -119,9 +102,9 @@ const newGuard = async (tx, description, table, root) => {
         }
         else {
             if (item.value === undefined || item.value === null) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NewGuardCheckFailed, `Table item value is required when b_submission is false`);
+                W_ERROR(WErrors.NewGuardCheckFailed, `Table item value is required when b_submission is false`);
             }
-            bcsValue = await (0, util_js_1.valueToBcsBytes)(valueType, item.value);
+            bcsValue = await valueToBcsBytes(valueType, item.value);
         }
         tableItems.push(tx.moveCall({
             target: guardFn("table_item"),
@@ -129,80 +112,79 @@ const newGuard = async (tx, description, table, root) => {
                 tx.pure.u8(item.identifier),
                 tx.pure.bool(item.b_submission),
                 tx.pure.vector("u8", Array.from(bcsValue)),
-                (0, common_js_1.toTxString)(tx, item.name),
+                toTxString(tx, item.name),
             ],
         }));
     }
     return tx.moveCall({
         target: guardFn("new"),
         arguments: [
-            (0, common_js_1.toTxString)(tx, description),
+            toTxString(tx, description),
             tx.makeMoveVec({
                 elements: tableItems,
-                type: `${common_js_1.PackageAddress}::guard::TableItem`,
+                type: `${PackageAddress}::guard::TableItem`,
             }),
             tx.pure.vector("u8", Array.from(input)),
         ],
     });
 };
-exports.newGuard = newGuard;
-function create(tx, guard) {
+export function create(tx, guard) {
     return tx.moveCall({
         target: guardFn("create"),
         arguments: [
-            (0, common_js_1.toTxObject)(tx, guard),
+            toTxObject(tx, guard),
             tx.object.mutRegistrar(),
             tx.object.clock(),
         ],
     });
 }
-function reliesAdd(tx, guard, rely_guards) {
-    const guards = lodash_1.default.uniq(rely_guards);
-    if (guards.length > common_js_1.MAX_DEPENDED_COUNT) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NewGuardCheckFailed, `Relies count exceeds maximum limit ${common_js_1.MAX_DEPENDED_COUNT}`);
+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}`);
     }
     guards.forEach((g) => {
         if (g === guard) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NewGuardCheckFailed, `Guard cannot rely on itself`);
+            W_ERROR(WErrors.NewGuardCheckFailed, `Guard cannot rely on itself`);
         }
         tx.moveCall({
             target: guardFn("relies_add"),
             arguments: [
-                (0, common_js_1.toTxObject)(tx, guard),
-                (0, common_js_1.toTxObject)(tx, g),
+                toTxObject(tx, guard),
+                toTxObject(tx, g),
                 tx.object.mutRegistrar(),
                 tx.object.clock(),
             ],
         });
     });
 }
-function reliesRemove(tx, guard, rely_guards) {
-    const guards = lodash_1.default.uniq(rely_guards);
-    if (guards.length > common_js_1.MAX_DEPENDED_COUNT) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NewGuardCheckFailed, `Relies count exceeds maximum limit ${common_js_1.MAX_DEPENDED_COUNT}`);
+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: [
-                (0, common_js_1.toTxObject)(tx, guard),
-                (0, common_js_1.toTxObject)(tx, g),
+                toTxObject(tx, guard),
+                toTxObject(tx, g),
                 tx.object.mutRegistrar(),
             ],
         });
     });
 }
-function reliesClear(tx, guard) {
+export function reliesClear(tx, guard) {
     tx.moveCall({
         target: guardFn("relies_clear"),
-        arguments: [(0, common_js_1.toTxObject)(tx, guard), tx.object.mutRegistrar()],
+        arguments: [toTxObject(tx, guard), tx.object.mutRegistrar()],
     });
 }
 // set the logic(and/or) of the guard; default is and
-function reliesLogic(tx, guard, logic_and) {
+export function reliesLogic(tx, guard, logic_and) {
     tx.moveCall({
         target: guardFn("relies_logic_and"),
-        arguments: [(0, common_js_1.toTxObject)(tx, guard), tx.pure.bool(logic_and)],
+        arguments: [toTxObject(tx, guard), tx.pure.bool(logic_and)],
     });
 }
 // ================================================
@@ -212,69 +194,69 @@ const buildNode = async (guard_node, type_required, table, output) => {
         case "identifier": {
             const f = table.find((v) => v.identifier === node.identifier);
             if (f) {
-                const fValueType = (0, common_js_1.parseValueType)(f.value_type);
-                (0, util_js_2.checkType)(fValueType, type_required, node);
-                output.push(index_js_1.bcs.U8.serialize(common_js_1.ContextType.TypeConstant).toBytes());
-                output.push(index_js_1.bcs.U8.serialize(node.identifier).toBytes());
+                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 {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "node identifier - " + JSON.stringify(node));
+                W_ERROR(WErrors.InvalidParam, "node identifier - " + JSON.stringify(node));
             }
             break;
         }
         case "query": {
-            const q = (0, guard_ins_js_1.getGuardQueryInfo)(node.query);
+            const q = getGuardQueryInfo(node.query);
             if (!q) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `query not found: ${node.query}`);
+                W_ERROR(WErrors.InvalidParam, `query not found: ${node.query}`);
             }
-            (0, util_js_2.checkType)(q.return, type_required, node);
+            checkType(q.return, type_required, node);
             if (q.parameters.length === node.parameters.length) {
                 for (let i = node.parameters.length - 1; i >= 0; --i) {
                     await buildNode(node.parameters[i], q.parameters[i], table, output);
                 }
             }
             else {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "node query parameters length not match - " +
+                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) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "node object from identifier - " + JSON.stringify(node));
+                W_ERROR(WErrors.InvalidParam, "node object from identifier - " + JSON.stringify(node));
             }
-            const tableItemValueType = (0, common_js_1.parseValueType)(tableItem.value_type);
-            if (tableItemValueType !== common_js_1.ValueType.Address) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `object to query must be address in table ${tableItem}. ${node.object}`);
+            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(index_js_1.bcs.U8.serialize(common_js_1.OperatorType.TypeQuery).toBytes());
-            if ((0, common_js_1.isWitnessType)(node.object.convert_witness)) {
-                const target = (0, object_js_1.WitnessTargetType)(node.object.convert_witness);
+            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) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `witness object type(${target}) not consistent with query object type(${q.objectType})`);
+                    W_ERROR(WErrors.InvalidParam, `witness object type(${target}) not consistent with query object type(${q.objectType})`);
                 }
-                const source = (0, object_js_1.WitnessSourceType)(node.object.convert_witness);
+                const source = WitnessSourceType(node.object.convert_witness);
                 if (tableItem.object_type) {
                     if (tableItem.object_type !== source) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `witness object type(${source}) not consistent with query object type(${tableItem.object_type})`);
+                        W_ERROR(WErrors.InvalidParam, `witness object type(${source}) not consistent with query object type(${tableItem.object_type})`);
                     }
                 }
                 else {
                     tableItem.object_type = source;
                 }
-                output.push(index_js_1.bcs.U8.serialize(node.object.convert_witness).toBytes());
+                output.push(bcs.U8.serialize(node.object.convert_witness).toBytes());
             }
             else {
                 if (tableItem?.object_type) {
                     if (tableItem.object_type !== q.objectType) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `witness object type(${q.objectType}) not consistent with query object type(${tableItem.object_type})`);
+                        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(index_js_1.bcs.U8.serialize(common_js_1.ContextType.TypeConstant).toBytes());
+                output.push(bcs.U8.serialize(ContextType.TypeConstant).toBytes());
             }
-            output.push(index_js_1.bcs.U8.serialize(node.object.identifier).toBytes());
-            output.push(index_js_1.bcs.U16.serialize(q.id).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":
@@ -297,25 +279,25 @@ const buildNode = async (guard_node, type_required, table, output) => {
         case "calc_string_nocase_equal":
         case "calc_string_contains": {
             const opCodeMap = {
-                logic_as_u256_greater_or_equal: common_js_1.OperatorType.TypeLogicAsU256GreaterEqual,
-                logic_as_u256_lesser_or_equal: common_js_1.OperatorType.TypeLogicAsU256LesserEqual,
-                logic_as_u256_equal: common_js_1.OperatorType.TypeLogicAsU256Equal,
-                logic_as_u256_greater: common_js_1.OperatorType.TypeLogicAsU256Greater,
-                logic_as_u256_lesser: common_js_1.OperatorType.TypeLogicAsU256Lesser,
-                logic_equal: common_js_1.OperatorType.TypeLogicEqual,
-                logic_and: common_js_1.OperatorType.TypeLogicAnd,
-                logic_or: common_js_1.OperatorType.TypeLogicOr,
-                logic_string_contains: common_js_1.OperatorType.TypeStringContains,
-                logic_string_nocase_contains: common_js_1.OperatorType.TypeStringNocaseContains,
-                logic_string_nocase_equal: common_js_1.OperatorType.TypeStringNocaseEqual,
-                calc_number_add: common_js_1.OperatorType.TypeNumberAdd,
-                calc_number_subtract: common_js_1.OperatorType.TypeNumberSubtract,
-                calc_number_multiply: common_js_1.OperatorType.TypeNumberMultiply,
-                calc_number_divide: common_js_1.OperatorType.TypeNumberDivide,
-                calc_number_mod: common_js_1.OperatorType.TypeNumberMod,
-                calc_string_nocase_contains: common_js_1.OperatorType.TypeStringNocaseContains,
-                calc_string_nocase_equal: common_js_1.OperatorType.TypeStringNocaseEqual,
-                calc_string_contains: common_js_1.OperatorType.TypeStringContains,
+                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",
@@ -324,42 +306,42 @@ const buildNode = async (guard_node, type_required, table, output) => {
                 logic_as_u256_greater: "number",
                 logic_as_u256_lesser: "number",
                 logic_equal: "variable",
-                logic_and: common_js_1.ValueType.Bool,
-                logic_or: common_js_1.ValueType.Bool,
-                logic_string_contains: common_js_1.ValueType.String,
-                logic_string_nocase_contains: common_js_1.ValueType.String,
-                logic_string_nocase_equal: common_js_1.ValueType.String,
+                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: common_js_1.ValueType.String,
-                calc_string_nocase_equal: common_js_1.ValueType.String,
-                calc_string_contains: common_js_1.ValueType.String,
+                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: common_js_1.ValueType.Bool,
-                logic_as_u256_lesser_or_equal: common_js_1.ValueType.Bool,
-                logic_as_u256_equal: common_js_1.ValueType.Bool,
-                logic_as_u256_greater: common_js_1.ValueType.Bool,
-                logic_as_u256_lesser: common_js_1.ValueType.Bool,
-                logic_equal: common_js_1.ValueType.Bool,
-                logic_and: common_js_1.ValueType.Bool,
-                logic_or: common_js_1.ValueType.Bool,
-                logic_string_contains: common_js_1.ValueType.Bool,
-                logic_string_nocase_contains: common_js_1.ValueType.Bool,
-                logic_string_nocase_equal: common_js_1.ValueType.Bool,
-                calc_number_add: common_js_1.ValueType.U256,
-                calc_number_subtract: common_js_1.ValueType.U256,
-                calc_number_multiply: common_js_1.ValueType.U256,
-                calc_number_divide: common_js_1.ValueType.U256,
-                calc_number_mod: common_js_1.ValueType.U256,
-                calc_string_nocase_contains: common_js_1.ValueType.Bool,
-                calc_string_nocase_equal: common_js_1.ValueType.Bool,
-                calc_string_contains: common_js_1.ValueType.Bool,
+                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,
             };
-            (0, util_js_2.checkType)(returnTypeMap[node.type], type_required, node);
+            checkType(returnTypeMap[node.type], type_required, node);
             await multi_operand_op(opCodeMap[node.type], node.nodes, requiredTypeMap[node.type], table, output);
             break;
         }
@@ -369,34 +351,34 @@ const buildNode = async (guard_node, type_required, table, output) => {
         case "vec_contains_string_nocase":
         case "vec_contains_number": {
             const opCodeMap = {
-                vec_contains_bool: common_js_1.OperatorType.TypedValueVecContains_Bool,
-                vec_contains_address: common_js_1.OperatorType.TypedValueVecContains_Address,
-                vec_contains_string: common_js_1.OperatorType.TypedValueVecContains_String,
-                vec_contains_string_nocase: common_js_1.OperatorType.TypedValueVecContains_StringNoCase,
-                vec_contains_number: common_js_1.OperatorType.TypedValueVecContains_Number,
+                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: common_js_1.ValueType.VecBool,
-                vec_contains_address: common_js_1.ValueType.VecAddress,
-                vec_contains_string: common_js_1.ValueType.VecString,
-                vec_contains_string_nocase: common_js_1.ValueType.VecString,
+                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: common_js_1.ValueType.Bool,
-                vec_contains_address: common_js_1.ValueType.Address,
-                vec_contains_string: common_js_1.ValueType.String,
-                vec_contains_string_nocase: common_js_1.ValueType.String,
+                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",
             };
-            (0, util_js_2.checkType)(common_js_1.ValueType.Bool, type_required, node);
+            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(index_js_1.bcs.U8.serialize(opCodeMap[node.type]).toBytes());
-            output.push(index_js_1.bcs.U8.serialize(node.nodes.length).toBytes());
+            output.push(bcs.U8.serialize(opCodeMap[node.type]).toBytes());
+            output.push(bcs.U8.serialize(node.nodes.length).toBytes());
             break;
         }
         case "logic_not":
@@ -414,29 +396,29 @@ const buildNode = async (guard_node, type_required, table, output) => {
         case "value_type":
         case "vec_length": {
             const opCodeMap = {
-                logic_not: common_js_1.OperatorType.TypeLogicNot,
-                calc_string_length: common_js_1.OperatorType.TypeStringLength,
-                convert_number_address: common_js_1.OperatorType.TypeNumberAddress,
-                convert_address_number: common_js_1.OperatorType.TypeAddressNumber,
-                convert_number_string: common_js_1.OperatorType.TypeNumberString,
-                convert_string_number: common_js_1.OperatorType.TypeStringNumber,
+                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: common_js_1.OperatorType.TypeSafeU8,
-                convert_safe_u16: common_js_1.OperatorType.TypeSafeU16,
-                convert_safe_u32: common_js_1.OperatorType.TypeSafeU32,
-                convert_safe_u64: common_js_1.OperatorType.TypeSafeU64,
-                convert_safe_u128: common_js_1.OperatorType.TypeSafeU128,
-                convert_safe_u256: common_js_1.OperatorType.TypeSafeU256,
-                value_type: common_js_1.OperatorType.TypedValueType,
-                vec_length: common_js_1.OperatorType.TypedValueVecLength,
+                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: common_js_1.ValueType.Bool,
-                calc_string_length: common_js_1.ValueType.String,
+                logic_not: ValueType.Bool,
+                calc_string_length: ValueType.String,
                 convert_number_address: "number",
-                convert_address_number: common_js_1.ValueType.Address,
+                convert_address_number: ValueType.Address,
                 convert_number_string: "number",
-                convert_string_number: common_js_1.ValueType.String,
+                convert_string_number: ValueType.String,
                 convert_safe_u8: "number",
                 convert_safe_u16: "number",
                 convert_safe_u32: "number",
@@ -447,37 +429,37 @@ const buildNode = async (guard_node, type_required, table, output) => {
                 vec_length: "vec",
             };
             const returnTypeMap = {
-                logic_not: common_js_1.ValueType.Bool,
-                calc_string_length: common_js_1.ValueType.U64,
-                convert_number_address: common_js_1.ValueType.Address,
-                convert_address_number: common_js_1.ValueType.U256,
-                convert_number_string: common_js_1.ValueType.String,
-                convert_string_number: common_js_1.ValueType.U256,
-                convert_safe_u8: common_js_1.ValueType.U8,
-                convert_safe_u16: common_js_1.ValueType.U16,
-                convert_safe_u32: common_js_1.ValueType.U32,
-                convert_safe_u64: common_js_1.ValueType.U64,
-                convert_safe_u128: common_js_1.ValueType.U128,
-                convert_safe_u256: common_js_1.ValueType.U256,
-                value_type: common_js_1.ValueType.U8,
-                vec_length: common_js_1.ValueType.U64,
+                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,
             };
-            (0, util_js_2.checkType)(returnTypeMap[node.type], type_required, node);
+            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: common_js_1.OperatorType.TypeStringIndexof,
-                calc_string_nocase_indexof: common_js_1.OperatorType.TypeStringNocaseIndexof,
+                calc_string_indexof: OperatorType.TypeStringIndexof,
+                calc_string_nocase_indexof: OperatorType.TypeStringNocaseIndexof,
             };
-            (0, util_js_2.checkType)(common_js_1.ValueType.U64, type_required, node);
+            checkType(ValueType.U64, type_required, node);
             //@ 第一个元素在栈顶
-            await buildNode(node.nodeRight, common_js_1.ValueType.String, table, output);
-            await buildNode(node.nodeLeft, common_js_1.ValueType.String, table, output);
-            output.push(index_js_1.bcs.U8.serialize(opCodeMap[node.type]).toBytes());
-            output.push(index_js_1.bcs.U8.serialize(node.order === "forward" ? 0 : 1).toBytes());
+            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":
@@ -486,73 +468,73 @@ const buildNode = async (guard_node, type_required, table, output) => {
         case "vec_indexof_string_nocase":
         case "vec_indexof_number": {
             const opCodeMap = {
-                vec_indexof_bool: common_js_1.OperatorType.TypedValueVecIndexOf_Bool,
-                vec_indexof_address: common_js_1.OperatorType.TypedValueVecIndexOf_Address,
-                vec_indexof_string: common_js_1.OperatorType.TypedValueVecIndexOf_String,
-                vec_indexof_string_nocase: common_js_1.OperatorType.TypedValueVecIndexOf_StringNoCase,
-                vec_indexof_number: common_js_1.OperatorType.TypedValueVecIndexOf_Number,
+                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: common_js_1.ValueType.Bool,
-                vec_indexof_address: common_js_1.ValueType.Address,
-                vec_indexof_string: common_js_1.ValueType.String,
-                vec_indexof_string_nocase: common_js_1.ValueType.String,
+                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: common_js_1.ValueType.VecBool,
-                vec_indexof_address: common_js_1.ValueType.VecAddress,
-                vec_indexof_string: common_js_1.ValueType.VecString,
-                vec_indexof_string_nocase: common_js_1.ValueType.VecString,
+                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",
             };
-            (0, util_js_2.checkType)(common_js_1.ValueType.U64, type_required, node);
+            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(index_js_1.bcs.U8.serialize(opCodeMap[node.type]).toBytes());
-            output.push(index_js_1.bcs.U8.serialize(node.order === "forward" ? 0 : 1).toBytes());
+            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 = common_js_1.ContextType.TypeSigner;
+                    contextValue = ContextType.TypeSigner;
                     break;
                 case "Clock":
-                    contextValue = common_js_1.ContextType.TypeClock;
+                    contextValue = ContextType.TypeClock;
                     break;
                 case "Guard":
-                    contextValue = common_js_1.ContextType.TypeGuard;
+                    contextValue = ContextType.TypeGuard;
                     break;
                 default:
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "Invalid context type: " + node.context);
+                    W_ERROR(WErrors.InvalidParam, "Invalid context type: " + node.context);
             }
-            output.push(index_js_1.bcs.U8.serialize(contextValue).toBytes());
-            (0, util_js_2.checkType)(common_js_1.ValueType.Address, type_required, node);
+            output.push(bcs.U8.serialize(contextValue).toBytes());
+            checkType(ValueType.Address, type_required, node);
             break;
         }
         default:
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "node:" + JSON.stringify(node));
+            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 > common_js_1.MAX_MULTI_OPERANDS) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `op ${op_code} parameters length must >= 2 and <=  
-				${common_js_1.MAX_MULTI_OPERANDS}. 	parameters:
+    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)}`);
     }
     //@ 和query一样，栈顶是第一个参数
     for (let i = parameters.length - 1; i >= 0; --i) {
         await buildNode(parameters[i], required_type, table, output);
     }
-    output.push(index_js_1.bcs.U8.serialize(op_code).toBytes()); // TYPE
-    output.push(index_js_1.bcs.U8.serialize(parameters.length).toBytes());
+    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(index_js_1.bcs.U8.serialize(op_code).toBytes()); // TYPE
+    output.push(bcs.U8.serialize(op_code).toBytes()); // TYPE
 };
 /**
  * Query Guard object data and export to JSON or Markdown file
@@ -562,20 +544,20 @@ const single_operand_op = async (op_code, parameter, required_type, table, outpu
  * @param network - Network entrypoint
  * @throws Error if query fails or file write fails
  */
-const guard2file = async (guard, file_path, format = "json", network) => {
+export const guard2file = async (guard, file_path, format = "json", network) => {
     // Query Guard object
-    const queryResult = await (0, object_js_1.query_objects)({
+    const queryResult = await query_objects({
         objects: [guard],
         network,
     });
     const objects = queryResult.objects;
     if (!objects || objects.length === 0 || objects[0].type !== "Guard") {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `guard2file: Guard object not found: ${guard}`);
+        W_ERROR(WErrors.InvalidParam, `guard2file: Guard object not found: ${guard}`);
         return;
     }
     const guardObj = objects[0];
     if (!guardObj) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `guard2file: Failed to get Guard object data: ${guard}`);
+        W_ERROR(WErrors.InvalidParam, `guard2file: Failed to get Guard object data: ${guard}`);
         return;
     }
     // Prepare output content based on format
@@ -588,14 +570,13 @@ const guard2file = async (guard, file_path, format = "json", network) => {
     }
     // Write to file
     try {
-        const resolvedPath = (0, path_1.resolve)(file_path);
-        (0, fs_1.writeFileSync)(resolvedPath, content, "utf-8");
+        const resolvedPath = resolve(file_path);
+        writeFileSync(resolvedPath, content, "utf-8");
     }
     catch (e) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `guard2file: Failed to write file '${file_path}': ${e.message}`);
+        W_ERROR(WErrors.InvalidParam, `guard2file: Failed to write file '${file_path}': ${e.message}`);
     }
 };
-exports.guard2file = guard2file;
 /**
  * Generate JSON format Guard definition with comments
  */
@@ -659,7 +640,7 @@ const generateGuardMarkdown = (guardObj) => {
     lines.push("|------------|--------------|------------|-------|------|");
     if (guardObj.table && guardObj.table.length > 0) {
         for (const item of guardObj.table) {
-            const itemValueType = (0, common_js_1.parseValueType)(item.value_type);
+            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} |`);
@@ -680,7 +661,7 @@ const generateGuardMarkdown = (guardObj) => {
         lines.push("```");
         lines.push("");
         // Add node comments
-        const nodeComments = (0, exports.generateNodeComments)(guardObj.root);
+        const nodeComments = generateNodeComments(guardObj.root);
         if (nodeComments.length > 0) {
             lines.push("### Node Comments");
             lines.push("");
@@ -743,14 +724,14 @@ const formatValueForMarkdown = (value) => {
 /**
  * Generate comments for Guard nodes
  */
-const generateNodeComments = (node, comments = []) => {
+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 = guard_ins_js_1.GUARDQUERY.find((q) => q.id === queryId);
+            const queryInfo = GUARDQUERY.find((q) => q.id === queryId);
             if (queryInfo) {
                 comments.push({
                     type: `query(${node.query})`,
@@ -780,60 +761,59 @@ const generateNodeComments = (node, comments = []) => {
     // Recursively process child nodes
     if ("nodes" in node && Array.isArray(node.nodes)) {
         for (const childNode of node.nodes) {
-            (0, exports.generateNodeComments)(childNode, comments);
+            generateNodeComments(childNode, comments);
         }
     }
     if ("node" in node && node.node) {
-        (0, exports.generateNodeComments)(node.node, comments);
+        generateNodeComments(node.node, comments);
     }
     if ("parameters" in node && Array.isArray(node.parameters)) {
         for (const param of node.parameters) {
-            (0, exports.generateNodeComments)(param, comments);
+            generateNodeComments(param, comments);
         }
     }
     if ("nodeLeft" in node && node.nodeLeft) {
-        (0, exports.generateNodeComments)(node.nodeLeft, comments);
+        generateNodeComments(node.nodeLeft, comments);
     }
     if ("nodeRight" in node && node.nodeRight) {
-        (0, exports.generateNodeComments)(node.nodeRight, comments);
+        generateNodeComments(node.nodeRight, comments);
     }
     return comments;
 };
-exports.generateNodeComments = generateNodeComments;
 /**
  * Convert ValueType enum to string representation
  */
 const valueTypeToString = (valueType) => {
     const typeMap = {
-        [common_js_1.ValueType.Bool]: "Bool",
-        [common_js_1.ValueType.Address]: "Address",
-        [common_js_1.ValueType.String]: "String",
-        [common_js_1.ValueType.U8]: "U8",
-        [common_js_1.ValueType.U16]: "U16",
-        [common_js_1.ValueType.U32]: "U32",
-        [common_js_1.ValueType.U64]: "U64",
-        [common_js_1.ValueType.U128]: "U128",
-        [common_js_1.ValueType.U256]: "U256",
-        [common_js_1.ValueType.VecBool]: "VecBool",
-        [common_js_1.ValueType.VecAddress]: "VecAddress",
-        [common_js_1.ValueType.VecString]: "VecString",
-        [common_js_1.ValueType.VecU8]: "VecU8",
-        [common_js_1.ValueType.VecU16]: "VecU16",
-        [common_js_1.ValueType.VecU32]: "VecU32",
-        [common_js_1.ValueType.VecU64]: "VecU64",
-        [common_js_1.ValueType.VecU128]: "VecU128",
-        [common_js_1.ValueType.VecU256]: "VecU256",
-        [common_js_1.ValueType.VecVecU8]: "VecVecU8",
-        [common_js_1.ValueType.Value]: "Value",
+        [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 (!(0, sui_types_js_1.isValidWowAddress)(guard)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "guard invalid: guard empty");
+export const gen_passport = async (env, guard, info) => {
+    if (!isValidWowAddress(guard)) {
+        W_ERROR(WErrors.InvalidParam, "guard invalid: guard empty");
     }
-    await (0, util_js_2.resolveCallEnv)(env);
-    const s = await (0, passport_js_1.get_guardSubmissions)(env, [guard]);
+    await resolveCallEnv(env);
+    const s = await get_guardSubmissions(env, [guard]);
     if (s.submission.length > 0) {
         if (!info) {
             return {
@@ -843,18 +823,17 @@ const gen_passport = async (env, guard, info) => {
             };
         }
         else {
-            return await (0, passport_js_1.verify_guard)(env, info);
+            return await verify_guard(env, info);
         }
     }
     else {
-        return await (0, passport_js_1.verify_guard)(env, {
+        return await verify_guard(env, {
             type: "submission",
             guard: [{ object: guard, impack: true }],
             submission: [],
         });
     }
 };
-exports.gen_passport = gen_passport;
 /**
  * Detect file format from content or extension
  */
@@ -959,7 +938,7 @@ function parseRelyFromMarkdown(section) {
  * Parse Guard definition from markdown content
  * Unified parsing logic shared between SDK and MCP
  */
-function parseGuardFromMarkdown(content) {
+export function parseGuardFromMarkdown(content) {
     const errors = [];
     const result = {};
     // Try to extract full JSON from code blocks first
@@ -1041,7 +1020,7 @@ function parseGuardFromMarkdown(content) {
  * Supports both JSON and Markdown formats
  * Unified parsing logic shared between SDK and MCP
  */
-function parseGuardFile(content, format) {
+export function parseGuardFile(content, format) {
     const detectedFormat = format ?? detectFileFormatFromContent(content);
     if (detectedFormat === "json") {
         try {
@@ -1078,7 +1057,7 @@ function parseGuardFile(content, format) {
  * Validate GuardNode structure
  * Basic validation without Zod dependency
  */
-function validateGuardNode(node) {
+export function validateGuardNode(node) {
     const errors = [];
     if (!node || typeof node !== "object") {
         errors.push({ message: "GuardNode must be an object", path: "/" });
@@ -1154,7 +1133,7 @@ function validateGuardNode(node) {
 /**
  * Format parse errors for display
  */
-function formatGuardParseErrors(errors) {
+export function formatGuardParseErrors(errors) {
     return errors
         .map((e) => {
         let msg = `Path: ${e.path}`;