wowok 2.1.9 → 2.1.12

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

@@ -1,661 +1,630 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var util_exports = {};
-__export(util_exports, {
-  checkType: () => checkType,
-  getCallEnvAccount: () => getCallEnvAccount,
-  resolveCallEnv: () => resolveCallEnv,
-  restoreNodeFromOutput: () => restoreNodeFromOutput
-});
-module.exports = __toCommonJS(util_exports);
-var import_bcs = require("../../bcs/index.js");
-var import_common = require("../common.js");
-var import_common2 = require("../common.js");
-var import_exception = require("../exception.js");
-var import_local = require("../local/index.js");
-var import_local2 = require("../local/local.js");
-var import_guard_ins = require("./guard-ins.js");
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreNodeFromOutput = exports.checkType = exports.resolveCallEnv = exports.getCallEnvAccount = void 0;
+const index_js_1 = require("../../bcs/index.js");
+const common_js_1 = require("../common.js");
+const common_js_2 = require("../common.js");
+const exception_js_1 = require("../exception.js");
+const index_js_2 = require("../local/index.js");
+const local_js_1 = require("../local/local.js");
+const guard_ins_js_1 = require("./guard-ins.js");
 const getCallEnvAccount = async (env) => {
-  const acc = await (0, import_local.GetAccountOrMark_Address)({
-    name_or_address: env.account || ""
-  });
-  if (!acc) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `account ${env.account} not found`);
-  }
-  env.account = acc;
-  return acc;
+    const acc = await (0, index_js_2.GetAccountOrMark_Address)({
+        name_or_address: env.account || "",
+    });
+    if (!acc) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `account ${env.account} not found`);
+    }
+    env.account = acc;
+    return acc;
 };
+exports.getCallEnvAccount = getCallEnvAccount;
 function createSingleOperandNode(property, operand) {
-  const node = { type: property, node: operand };
-  return node;
+    const node = { type: property, node: operand };
+    return node;
 }
 const resolveCallEnv = async (env) => {
-  env.network = await import_local.Config.Instance().network_get(env?.network);
-  const acc = await getCallEnvAccount(env);
-  if (env?.permission_guard && env.permission_guard?.length > 0) {
-    const guards = await import_local2.LocalMark.Instance().get_many_address_availables(
-      env.permission_guard
-    );
-    if (guards.length !== env.permission_guard.length) {
-      const foundGuardSet = new Set(guards);
-      const notFoundGuards = env.permission_guard.filter(
-        (guard) => !foundGuardSet.has(guard)
-      );
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `permission_guard not found: ${notFoundGuards.join(", ")}`
-      );
-    }
-    env.permission_guard = [...guards];
-    if (env.permission_guard.length > import_common2.MAX_ENV_PERMISSION_GUARD_COUNT) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `permission_guard length ${env.permission_guard.length} exceeds ${import_common2.MAX_ENV_PERMISSION_GUARD_COUNT}`
-      );
+    env.network = await index_js_2.Config.Instance().network_get(env?.network);
+    const acc = await (0, exports.getCallEnvAccount)(env);
+    // 去重处理
+    if (env?.permission_guard && env.permission_guard?.length > 0) {
+        const guards = await local_js_1.LocalMark.Instance().get_many_address_availables(env.permission_guard);
+        if (guards.length !== env.permission_guard.length) {
+            // 找出没有找到的 guard
+            const foundGuardSet = new Set(guards);
+            const notFoundGuards = env.permission_guard.filter((guard) => !foundGuardSet.has(guard));
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `permission_guard not found: ${notFoundGuards.join(", ")}`);
+        }
+        env.permission_guard = [...guards];
+        if (env.permission_guard.length > common_js_2.MAX_ENV_PERMISSION_GUARD_COUNT) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `permission_guard length ${env.permission_guard.length} exceeds ${common_js_2.MAX_ENV_PERMISSION_GUARD_COUNT}`);
+        }
     }
-  }
-  if (env?.referrer) {
-    const r = await (0, import_local.GetAccountOrMark_Address)({
-      name_or_address: env.referrer || ""
-    });
-    if (r) {
-      env.referrer = r;
-    } else {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `referrer ${env.referrer} not found`);
+    if (env?.referrer) {
+        const r = await (0, index_js_2.GetAccountOrMark_Address)({
+            name_or_address: env.referrer || "",
+        });
+        if (r) {
+            env.referrer = r;
+        }
+        else {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `referrer ${env.referrer} not found`);
+        }
     }
-  }
-  return acc;
+    return acc;
 };
+exports.resolveCallEnv = resolveCallEnv;
+// ================================================
+// 从output和table恢复GuardNode的函数
+// ================================================
 const checkType = (type, type_required, node) => {
-  if (type_required === "variable") {
-    return;
-  } else if (type_required === "number") {
-    if ((0, import_common.isValueTypeNumber)(type) || type === import_common2.ContextType.TypeClock || type === import_common.ValueType.Value) {
-      return;
+    if (type_required === "variable") {
+        return;
+    }
+    else if (type_required === "number") {
+        if ((0, common_js_1.isValueTypeNumber)(type) ||
+            type === common_js_2.ContextType.TypeClock ||
+            type === common_js_1.ValueType.Value) {
+            return;
+        }
+    }
+    else if (type_required === common_js_1.ValueType.Address) {
+        if (type === common_js_2.ContextType.TypeSigner ||
+            type === common_js_2.ContextType.TypeGuard ||
+            type === common_js_1.ValueType.Value) {
+            return;
+        }
     }
-  } else if (type_required === import_common.ValueType.Address) {
-    if (type === import_common2.ContextType.TypeSigner || type === import_common2.ContextType.TypeGuard || type === import_common.ValueType.Value) {
-      return;
+    else if (type === common_js_1.ValueType.Value) {
+        // Value 是动态类型，可以匹配任何具体类型
+        return;
     }
-  } else if (type === import_common.ValueType.Value) {
-    return;
-  } else if (type_required === import_common.ValueType.Value) {
-    return;
-  } else if (type_required === "vec_number") {
-    if (type === import_common.ValueType.VecU8 || type === import_common.ValueType.VecU16 || type === import_common.ValueType.VecU32 || type === import_common.ValueType.VecU64 || type === import_common.ValueType.VecU128 || type === import_common.ValueType.VecU256) {
-      return;
+    else if (type_required === common_js_1.ValueType.Value) {
+        // 任何类型都可以赋值给 Value 类型
+        return;
     }
-  } else if (type_required === "vec") {
-    if (type === import_common.ValueType.VecBool || type === import_common.ValueType.VecAddress || type === import_common.ValueType.VecString || type === import_common.ValueType.VecU8 || type === import_common.ValueType.VecU16 || type === import_common.ValueType.VecU32 || type === import_common.ValueType.VecU64 || type === import_common.ValueType.VecU128 || type === import_common.ValueType.VecU256) {
-      return;
+    else if (type_required === "vec_number") {
+        if (type === common_js_1.ValueType.VecU8 ||
+            type === common_js_1.ValueType.VecU16 ||
+            type === common_js_1.ValueType.VecU32 ||
+            type === common_js_1.ValueType.VecU64 ||
+            type === common_js_1.ValueType.VecU128 ||
+            type === common_js_1.ValueType.VecU256) {
+            return;
+        }
+    }
+    else if (type_required === "vec") {
+        if (type === common_js_1.ValueType.VecBool ||
+            type === common_js_1.ValueType.VecAddress ||
+            type === common_js_1.ValueType.VecString ||
+            type === common_js_1.ValueType.VecU8 ||
+            type === common_js_1.ValueType.VecU16 ||
+            type === common_js_1.ValueType.VecU32 ||
+            type === common_js_1.ValueType.VecU64 ||
+            type === common_js_1.ValueType.VecU128 ||
+            type === common_js_1.ValueType.VecU256) {
+            return;
+        }
+    }
+    if (type !== type_required) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `checkType: ${type} require type: ${type_required} with node: ${JSON.stringify(node)}`);
     }
-  }
-  if (type !== type_required) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `checkType: ${type} require type: ${type_required} with node: ${JSON.stringify(node)}`
-    );
-  }
 };
+exports.checkType = checkType;
+// 从链上获取数据，就不用再checkType
 const parseNode = (parserState) => {
-  if (parserState.currentPosition >= parserState.output.length) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      "parseNode: Unexpected end of output while parsing node"
-    );
-  }
-  const opCode = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  switch (opCode) {
-    case import_common2.ContextType.TypeConstant:
-      if (parserState.currentPosition >= parserState.output.length) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "parseNode: Missing identifier after TypeConstant opcode"
-        );
-      }
-      const identifierByte = parserState.output[parserState.currentPosition];
-      parserState.currentPosition++;
-      return { type: "identifier", identifier: identifierByte };
-    case import_common.OperatorType.TypeQuery:
-      return parseQueryNode(parserState);
-    case import_common.OperatorType.TypeLogicAsU256GreaterEqual:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_as_u256_greater_or_equal"
-      );
-    case import_common.OperatorType.TypeLogicAsU256LesserEqual:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_as_u256_lesser_or_equal"
-      );
-    case import_common.OperatorType.TypeLogicAsU256Equal:
-      return parseMultiOperandNode(parserState, "logic_as_u256_equal");
-    case import_common.OperatorType.TypeLogicAsU256Greater:
-      return parseMultiOperandNode(parserState, "logic_as_u256_greater");
-    case import_common.OperatorType.TypeLogicAsU256Lesser:
-      return parseMultiOperandNode(parserState, "logic_as_u256_lesser");
-    case import_common.OperatorType.TypeLogicEqual:
-      return parseMultiOperandNode(parserState, "logic_equal");
-    case import_common.OperatorType.TypeLogicAnd:
-      return parseMultiOperandNode(parserState, "logic_and");
-    case import_common.OperatorType.TypeLogicOr:
-      return parseMultiOperandNode(parserState, "logic_or");
-    case import_common.OperatorType.TypeStringContains:
-      return parseMultiOperandNode(parserState, "logic_string_contains");
-    case import_common.OperatorType.TypeStringNocaseContains:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_string_nocase_contains"
-      );
-    case import_common.OperatorType.TypeStringNocaseEqual:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_string_nocase_equal"
-      );
-    case import_common.OperatorType.TypeNumberAdd:
-      return parseMultiOperandNode(parserState, "calc_number_add");
-    case import_common.OperatorType.TypeNumberSubtract:
-      return parseMultiOperandNode(parserState, "calc_number_subtract");
-    case import_common.OperatorType.TypeNumberMultiply:
-      return parseMultiOperandNode(parserState, "calc_number_multiply");
-    case import_common.OperatorType.TypeNumberDivide:
-      return parseMultiOperandNode(parserState, "calc_number_divide");
-    case import_common.OperatorType.TypeNumberMod:
-      return parseMultiOperandNode(parserState, "calc_number_mod");
-    case import_common.OperatorType.TypeLogicNot:
-      return parseSingleOperandNode(parserState, "logic_not");
-    case import_common.OperatorType.TypeStringLength:
-      return parseSingleOperandNode(parserState, "calc_string_length");
-    case import_common.OperatorType.TypeNumberAddress:
-      return parseSingleOperandNode(
-        parserState,
-        "convert_number_address"
-      );
-    case import_common.OperatorType.TypeAddressNumber:
-      return parseSingleOperandNode(
-        parserState,
-        "convert_address_number"
-      );
-    case import_common.OperatorType.TypeNumberString:
-      return parseSingleOperandNode(parserState, "convert_number_string");
-    case import_common.OperatorType.TypeStringNumber:
-      return parseSingleOperandNode(parserState, "convert_string_number");
-    /*case OperatorType.TypeStringLowercase:
-    	return parseSingleOperandNode(
-    		parserState,
-    		"convert_string_lowercase",
-    	);*/
-    case import_common.OperatorType.TypeSafeU8:
-      return parseSingleOperandNode(parserState, "convert_safe_u8");
-    case import_common.OperatorType.TypeSafeU16:
-      return parseSingleOperandNode(parserState, "convert_safe_u16");
-    case import_common.OperatorType.TypeSafeU32:
-      return parseSingleOperandNode(parserState, "convert_safe_u32");
-    case import_common.OperatorType.TypeSafeU64:
-      return parseSingleOperandNode(parserState, "convert_safe_u64");
-    case import_common.OperatorType.TypeSafeU128:
-      return parseSingleOperandNode(parserState, "convert_safe_u128");
-    case import_common.OperatorType.TypeSafeU256:
-      return parseSingleOperandNode(parserState, "convert_safe_u256");
-    case import_common.OperatorType.TypeStringIndexof:
-      return parseTwoOperandNode(parserState, "calc_string_indexof");
-    case import_common.OperatorType.TypeStringNocaseIndexof:
-      return parseTwoOperandNode(
-        parserState,
-        "calc_string_nocase_indexof"
-      );
-    // typedValue 操作
-    case import_common.OperatorType.TypedValueType:
-      return parseSingleOperandNode(parserState, "value_type");
-    case import_common.OperatorType.TypedValueVecLength:
-      return parseSingleOperandNode(parserState, "vec_length");
-    case import_common.OperatorType.TypedValueVecContains_Bool:
-      return parseMultiOperandNode(parserState, "vec_contains_bool");
-    case import_common.OperatorType.TypedValueVecContains_Address:
-      return parseMultiOperandNode(parserState, "vec_contains_address");
-    case import_common.OperatorType.TypedValueVecContains_String:
-      return parseMultiOperandNode(parserState, "vec_contains_string");
-    case import_common.OperatorType.TypedValueVecContains_StringNoCase:
-      return parseMultiOperandNode(
-        parserState,
-        "vec_contains_string_nocase"
-      );
-    case import_common.OperatorType.TypedValueVecContains_Number:
-      return parseMultiOperandNode(parserState, "vec_contains_number");
-    case import_common.OperatorType.TypedValueVecIndexOf_Bool:
-      return parseTwoOperandNode(parserState, "vec_indexof_bool");
-    case import_common.OperatorType.TypedValueVecIndexOf_Address:
-      return parseTwoOperandNode(parserState, "vec_indexof_address");
-    case import_common.OperatorType.TypedValueVecIndexOf_String:
-      return parseTwoOperandNode(parserState, "vec_indexof_string");
-    case import_common.OperatorType.TypedValueVecIndexOf_StringNoCase:
-      return parseTwoOperandNode(
-        parserState,
-        "vec_indexof_string_nocase"
-      );
-    case import_common.OperatorType.TypedValueVecIndexOf_Number:
-      return parseTwoOperandNode(parserState, "vec_indexof_number");
-    case import_common2.ContextType.TypeSigner:
-      return { type: "context", context: "Signer" };
-    case import_common2.ContextType.TypeGuard:
-      return { type: "context", context: "Guard" };
-    case import_common2.ContextType.TypeClock:
-      return { type: "context", context: "Clock" };
-    default:
-      throw new Error(`ParseGuardNode: Unknown opcode: ${opCode}`);
-  }
+    if (parserState.currentPosition >= parserState.output.length) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseNode: Unexpected end of output while parsing node");
+    }
+    const opCode = parserState.output[parserState.currentPosition];
+    parserState.currentPosition++;
+    switch (opCode) {
+        case common_js_2.ContextType.TypeConstant: // TYPE_CONSTANT
+            if (parserState.currentPosition >= parserState.output.length) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseNode: Missing identifier after TypeConstant opcode");
+            }
+            const identifierByte = parserState.output[parserState.currentPosition];
+            parserState.currentPosition++;
+            /*从guard数据恢复，不查也没问题
+            const tableItem = parserState.table.find(
+                (item) => item.identifier === identifierByte,
+            );
+            if (!tableItem) {
+                W_ERROR(
+                    WErrors.InvalidParam,
+                    `parseNode: Identifier ${identifierByte} not found in table`,
+                );
+            }*/
+            return { type: "identifier", identifier: identifierByte };
+        case common_js_1.OperatorType.TypeQuery: // QUERY TYPE
+            return parseQueryNode(parserState);
+        case common_js_1.OperatorType.TypeLogicAsU256GreaterEqual:
+            return parseMultiOperandNode(parserState, "logic_as_u256_greater_or_equal");
+        case common_js_1.OperatorType.TypeLogicAsU256LesserEqual:
+            return parseMultiOperandNode(parserState, "logic_as_u256_lesser_or_equal");
+        case common_js_1.OperatorType.TypeLogicAsU256Equal:
+            return parseMultiOperandNode(parserState, "logic_as_u256_equal");
+        case common_js_1.OperatorType.TypeLogicAsU256Greater:
+            return parseMultiOperandNode(parserState, "logic_as_u256_greater");
+        case common_js_1.OperatorType.TypeLogicAsU256Lesser:
+            return parseMultiOperandNode(parserState, "logic_as_u256_lesser");
+        case common_js_1.OperatorType.TypeLogicEqual:
+            return parseMultiOperandNode(parserState, "logic_equal");
+        case common_js_1.OperatorType.TypeLogicAnd:
+            return parseMultiOperandNode(parserState, "logic_and");
+        case common_js_1.OperatorType.TypeLogicOr:
+            return parseMultiOperandNode(parserState, "logic_or");
+        case common_js_1.OperatorType.TypeStringContains:
+            return parseMultiOperandNode(parserState, "logic_string_contains");
+        case common_js_1.OperatorType.TypeStringNocaseContains:
+            return parseMultiOperandNode(parserState, "logic_string_nocase_contains");
+        case common_js_1.OperatorType.TypeStringNocaseEqual:
+            return parseMultiOperandNode(parserState, "logic_string_nocase_equal");
+        case common_js_1.OperatorType.TypeNumberAdd:
+            return parseMultiOperandNode(parserState, "calc_number_add");
+        case common_js_1.OperatorType.TypeNumberSubtract:
+            return parseMultiOperandNode(parserState, "calc_number_subtract");
+        case common_js_1.OperatorType.TypeNumberMultiply:
+            return parseMultiOperandNode(parserState, "calc_number_multiply");
+        case common_js_1.OperatorType.TypeNumberDivide:
+            return parseMultiOperandNode(parserState, "calc_number_divide");
+        case common_js_1.OperatorType.TypeNumberMod:
+            return parseMultiOperandNode(parserState, "calc_number_mod");
+        case common_js_1.OperatorType.TypeLogicNot:
+            return parseSingleOperandNode(parserState, "logic_not");
+        case common_js_1.OperatorType.TypeStringLength:
+            return parseSingleOperandNode(parserState, "calc_string_length");
+        case common_js_1.OperatorType.TypeNumberAddress:
+            return parseSingleOperandNode(parserState, "convert_number_address");
+        case common_js_1.OperatorType.TypeAddressNumber:
+            return parseSingleOperandNode(parserState, "convert_address_number");
+        case common_js_1.OperatorType.TypeNumberString:
+            return parseSingleOperandNode(parserState, "convert_number_string");
+        case common_js_1.OperatorType.TypeStringNumber:
+            return parseSingleOperandNode(parserState, "convert_string_number");
+        /*case OperatorType.TypeStringLowercase:
+            return parseSingleOperandNode(
+                parserState,
+                "convert_string_lowercase",
+            );*/
+        case common_js_1.OperatorType.TypeSafeU8:
+            return parseSingleOperandNode(parserState, "convert_safe_u8");
+        case common_js_1.OperatorType.TypeSafeU16:
+            return parseSingleOperandNode(parserState, "convert_safe_u16");
+        case common_js_1.OperatorType.TypeSafeU32:
+            return parseSingleOperandNode(parserState, "convert_safe_u32");
+        case common_js_1.OperatorType.TypeSafeU64:
+            return parseSingleOperandNode(parserState, "convert_safe_u64");
+        case common_js_1.OperatorType.TypeSafeU128:
+            return parseSingleOperandNode(parserState, "convert_safe_u128");
+        case common_js_1.OperatorType.TypeSafeU256:
+            return parseSingleOperandNode(parserState, "convert_safe_u256");
+        case common_js_1.OperatorType.TypeStringIndexof:
+            return parseTwoOperandNode(parserState, "calc_string_indexof");
+        case common_js_1.OperatorType.TypeStringNocaseIndexof:
+            return parseTwoOperandNode(parserState, "calc_string_nocase_indexof");
+        // typedValue 操作
+        case common_js_1.OperatorType.TypedValueType:
+            return parseSingleOperandNode(parserState, "value_type");
+        case common_js_1.OperatorType.TypedValueVecLength:
+            return parseSingleOperandNode(parserState, "vec_length");
+        case common_js_1.OperatorType.TypedValueVecContains_Bool:
+            return parseMultiOperandNode(parserState, "vec_contains_bool");
+        case common_js_1.OperatorType.TypedValueVecContains_Address:
+            return parseMultiOperandNode(parserState, "vec_contains_address");
+        case common_js_1.OperatorType.TypedValueVecContains_String:
+            return parseMultiOperandNode(parserState, "vec_contains_string");
+        case common_js_1.OperatorType.TypedValueVecContains_StringNoCase:
+            return parseMultiOperandNode(parserState, "vec_contains_string_nocase");
+        case common_js_1.OperatorType.TypedValueVecContains_Number:
+            return parseMultiOperandNode(parserState, "vec_contains_number");
+        case common_js_1.OperatorType.TypedValueVecIndexOf_Bool:
+            return parseTwoOperandNode(parserState, "vec_indexof_bool");
+        case common_js_1.OperatorType.TypedValueVecIndexOf_Address:
+            return parseTwoOperandNode(parserState, "vec_indexof_address");
+        case common_js_1.OperatorType.TypedValueVecIndexOf_String:
+            return parseTwoOperandNode(parserState, "vec_indexof_string");
+        case common_js_1.OperatorType.TypedValueVecIndexOf_StringNoCase:
+            return parseTwoOperandNode(parserState, "vec_indexof_string_nocase");
+        case common_js_1.OperatorType.TypedValueVecIndexOf_Number:
+            return parseTwoOperandNode(parserState, "vec_indexof_number");
+        case common_js_2.ContextType.TypeSigner:
+            return { type: "context", context: "Signer" };
+        case common_js_2.ContextType.TypeGuard:
+            return { type: "context", context: "Guard" };
+        case common_js_2.ContextType.TypeClock:
+            return { type: "context", context: "Clock" };
+        default:
+            throw new Error(`ParseGuardNode: Unknown opcode: ${opCode}`);
+    }
 };
 const parseMultiOperandNode = (parserState, nodeProperty) => {
-  if (parserState.currentPosition >= parserState.output.length) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      "parseMultiOperandNode: Insufficient data for multi-operand operation"
-    );
-  }
-  const operandCount = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  const operands = [];
-  for (let i = 0; i < operandCount; i++) {
-    operands.unshift(parseNode(parserState));
-  }
-  const node = {
-    type: nodeProperty,
-    nodes: operands
-  };
-  return node;
+    // For multi-operand operations, we need to read the operand count from the stream
+    if (parserState.currentPosition >= parserState.output.length) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseMultiOperandNode: Insufficient data for multi-operand operation");
+    }
+    // Read operand count (the next byte in the stream)
+    const operandCount = parserState.output[parserState.currentPosition];
+    parserState.currentPosition++;
+    // Parse operands in the order they appear in the stream
+    const operands = [];
+    // Standard multi-operand: all operands use same requiredType (parse in reverse order)
+    for (let i = 0; i < operandCount; i++) {
+        operands.unshift(parseNode(parserState));
+    }
+    const node = {
+        type: nodeProperty,
+        nodes: operands,
+    };
+    return node;
 };
 const parseSingleOperandNode = (parserState, nodeProperty) => {
-  const operand = parseNode(parserState);
-  return createSingleOperandNode(
-    nodeProperty,
-    operand
-  );
+    const operand = parseNode(parserState);
+    return createSingleOperandNode(nodeProperty, operand);
 };
 const parseTwoOperandNode = (parserState, nodeProperty) => {
-  if (parserState.currentPosition >= parserState.output.length) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      "parseTwoOperandNode: Missing order byte"
-    );
-  }
-  const orderByte = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  const order = orderByte === 0 ? "forward" : "backward";
-  const nodeRight = parseNode(parserState);
-  const nodeLeft = parseNode(parserState);
-  const node = {
-    type: nodeProperty,
-    nodeLeft,
-    nodeRight,
-    order
-  };
-  return node;
+    // Read order byte (0 = forward, 1 = backward)
+    if (parserState.currentPosition >= parserState.output.length) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseTwoOperandNode: Missing order byte");
+    }
+    const orderByte = parserState.output[parserState.currentPosition];
+    parserState.currentPosition++;
+    const order = orderByte === 0 ? "forward" : "backward";
+    // 右侧节点在前
+    const nodeRight = parseNode(parserState);
+    const nodeLeft = parseNode(parserState);
+    const node = {
+        type: nodeProperty,
+        nodeLeft,
+        nodeRight,
+        order,
+    };
+    return node;
 };
+// Helper function to handle parsing of query nodes with their parameters
 const parseQueryNode = (parserState) => {
-  if (parserState.currentPosition >= parserState.output.length) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      "parseQueryNode: Missing witness byte after TypeQuery opcode"
-    );
-  }
-  const witnessByte = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  if (parserState.currentPosition >= parserState.output.length) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      "parseQueryNode: Missing object identifier after witness byte"
-    );
-  }
-  const objectIdentifier = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  const remainingBytes = parserState.output.subarray(
-    parserState.currentPosition
-  );
-  if (remainingBytes.length < 2) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      "parseQueryNode: Not enough bytes for query ID after object identifier"
-    );
-  }
-  const queryId = import_bcs.bcs.U16.parse(remainingBytes);
-  parserState.currentPosition += 2;
-  const query = import_guard_ins.GUARDQUERY.find((q) => q.id === queryId);
-  if (!query) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `parseQueryNode: Query with ID ${queryId} not found`
-    );
-  }
-  const queryInfo = (0, import_guard_ins.getGuardQueryInfo)(queryId);
-  if (!queryInfo) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `parseQueryNode: Query name not found for ID ${queryId}`
-    );
-  }
-  const parameters = [];
-  const paramTypes = queryInfo.parameters;
-  for (let i = paramTypes.length - 1; i >= 0; i--) {
-    parameters.unshift(parseNode(parserState));
-  }
-  const node = {
-    type: "query",
-    query: queryInfo.name,
-    object: {
-      identifier: objectIdentifier,
-      ...witnessByte !== import_common2.ContextType.TypeConstant ? { convert_witness: witnessByte } : {}
-    },
-    parameters
-  };
-  return node;
-};
-const restoreNodeFromOutput = (output, table) => {
-  try {
-    if (!output || output.length === 0) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        "restoreNodeFromOutput: output is empty"
-      );
+    // Read the witness type (if present)
+    if (parserState.currentPosition >= parserState.output.length) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseQueryNode: Missing witness byte after TypeQuery opcode");
     }
-    const nodeStack = [];
-    const rep_quote = /* @__PURE__ */ new Map();
-    let position = 0;
-    const readByte = () => {
-      if (position >= output.length) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "readByte: Unexpected end of output"
-        );
-      }
-      return output[position++];
-    };
-    const readU16 = () => {
-      if (position + 2 > output.length) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "readU16: Insufficient bytes for u16"
-        );
-      }
-      const value = output[position] + output[position + 1] * 256;
-      position += 2;
-      return value;
+    const witnessByte = parserState.output[parserState.currentPosition];
+    parserState.currentPosition++;
+    // Read the object identifier
+    if (parserState.currentPosition >= parserState.output.length) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseQueryNode: Missing object identifier after witness byte");
+    }
+    const objectIdentifier = parserState.output[parserState.currentPosition];
+    parserState.currentPosition++;
+    // Read the query ID (u16)
+    const remainingBytes = parserState.output.subarray(parserState.currentPosition);
+    if (remainingBytes.length < 2) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseQueryNode: Not enough bytes for query ID after object identifier");
+    }
+    // Use BCS deserialization to read the u16 query ID
+    const queryId = index_js_1.bcs.U16.parse(remainingBytes);
+    parserState.currentPosition += 2;
+    // Find the query definition
+    const query = guard_ins_js_1.GUARDQUERY.find((q) => q.id === queryId);
+    if (!query) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `parseQueryNode: Query with ID ${queryId} not found`);
+    }
+    // Get full query info using the name
+    const queryInfo = (0, guard_ins_js_1.getGuardQueryInfo)(queryId);
+    if (!queryInfo) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `parseQueryNode: Query name not found for ID ${queryId}`);
+    }
+    // Parse parameters in reverse order (as serialized by buildNode)
+    const parameters = [];
+    const paramTypes = queryInfo.parameters;
+    for (let i = paramTypes.length - 1; i >= 0; i--) {
+        parameters.unshift(parseNode(parserState));
+    }
+    const node = {
+        type: "query",
+        query: queryInfo.name,
+        object: {
+            identifier: objectIdentifier,
+            ...(witnessByte !== common_js_2.ContextType.TypeConstant
+                ? { convert_witness: witnessByte }
+                : {}),
+        },
+        parameters,
     };
-    while (position < output.length) {
-      const opCode = readByte();
-      switch (opCode) {
-        case import_common2.ContextType.TypeConstant: {
-          const identifier = readByte();
-          nodeStack.push({ type: "identifier", identifier });
-          break;
+    return node;
+};
+// Main function to restore GuardNode from output and table
+// Uses a stack-based approach similar to the Rust implementation
+const restoreNodeFromOutput = (output, table) => {
+    try {
+        // Validate output format
+        if (!output || output.length === 0) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "restoreNodeFromOutput: output is empty");
         }
-        case import_common2.ContextType.TypeSigner:
-          nodeStack.push({ type: "context", context: "Signer" });
-          break;
-        case import_common2.ContextType.TypeClock:
-          nodeStack.push({ type: "context", context: "Clock" });
-          break;
-        case import_common2.ContextType.TypeGuard:
-          nodeStack.push({ type: "context", context: "Guard" });
-          break;
-        case import_common.OperatorType.TypeQuery: {
-          const witnessByte = readByte();
-          const identifier = readByte();
-          const queryId = readU16();
-          const queryInfo = (0, import_guard_ins.getGuardQueryInfo)(queryId);
-          if (!queryInfo) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `restoreNodeFromOutput: Query with ID ${queryId} not found`
-            );
-          }
-          const parameters = [];
-          for (let i = 0; i < queryInfo.parameters.length; i++) {
-            if (nodeStack.length === 0) {
-              (0, import_exception.W_ERROR)(
-                import_exception.WErrors.InvalidParam,
-                `restoreNodeFromOutput: Insufficient parameters for query ${queryInfo.name}`
-              );
+        // Use a stack to build the node tree, similar to Rust implementation
+        const nodeStack = [];
+        const rep_quote = new Map(); // rep - policies
+        let position = 0;
+        // Helper function to read a byte
+        const readByte = () => {
+            if (position >= output.length) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "readByte: Unexpected end of output");
             }
-            parameters.unshift(nodeStack.pop());
-          }
-          if (queryInfo.id === 1167 && parameters[0].type === "identifier" && // 来自于table
-          parameters[0]?.identifier != null) {
-            const rep_item = table.find(
-              (item) => item.identifier === identifier && !item.b_submission
-            );
-            const policy_item = table.find(
-              (item) => item.identifier === parameters[0].identifier && !item.b_submission
-            );
-            const repItemValueType = rep_item ? (0, import_common.parseValueType)(rep_item.value_type) : void 0;
-            const policyItemValueType = policy_item ? (0, import_common.parseValueType)(policy_item.value_type) : void 0;
-            if (rep_item && policy_item && repItemValueType === import_common.ValueType.Address && policyItemValueType === import_common.ValueType.String) {
-              if (rep_quote.has(rep_item.value)) {
-                if (!rep_quote.get(rep_item.value).includes(policy_item.value)) {
-                  rep_quote.get(rep_item.value).push(policy_item.value);
-                }
-              } else {
-                rep_quote.set(rep_item.value, [
-                  policy_item.value
-                ]);
-              }
+            return output[position++];
+        };
+        // Helper function to read a u16 (little-endian)
+        const readU16 = () => {
+            if (position + 2 > output.length) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "readU16: Insufficient bytes for u16");
             }
-          }
-          nodeStack.push({
-            type: "query",
-            query: queryInfo.name,
-            object: {
-              identifier,
-              ...witnessByte !== import_common2.ContextType.TypeConstant ? { convert_witness: witnessByte } : {}
-            },
-            parameters
-          });
-          break;
-        }
-        case import_common.OperatorType.TypeLogicEqual:
-        case import_common.OperatorType.TypeLogicAnd:
-        case import_common.OperatorType.TypeLogicOr:
-        case import_common.OperatorType.TypeLogicAsU256GreaterEqual:
-        case import_common.OperatorType.TypeLogicAsU256LesserEqual:
-        case import_common.OperatorType.TypeLogicAsU256Equal:
-        case import_common.OperatorType.TypeLogicAsU256Greater:
-        case import_common.OperatorType.TypeLogicAsU256Lesser:
-        case import_common.OperatorType.TypeStringContains:
-        case import_common.OperatorType.TypeStringNocaseContains:
-        case import_common.OperatorType.TypeStringNocaseEqual:
-        case import_common.OperatorType.TypeNumberAdd:
-        case import_common.OperatorType.TypeNumberSubtract:
-        case import_common.OperatorType.TypeNumberMultiply:
-        case import_common.OperatorType.TypeNumberDivide:
-        case import_common.OperatorType.TypeNumberMod: {
-          const operandCount = readByte();
-          const operands = [];
-          for (let i = 0; i < operandCount; i++) {
-            if (nodeStack.length === 0) {
-              (0, import_exception.W_ERROR)(
-                import_exception.WErrors.InvalidParam,
-                `restoreNodeFromOutput: Insufficient operands for multi-operand operation`
-              );
+            const value = output[position] + output[position + 1] * 256;
+            position += 2;
+            return value;
+        };
+        // Process the input byte by byte, similar to Rust
+        while (position < output.length) {
+            const opCode = readByte();
+            switch (opCode) {
+                case common_js_2.ContextType.TypeConstant: {
+                    // TYPE_CONSTANT (48)
+                    const identifier = readByte();
+                    nodeStack.push({ type: "identifier", identifier });
+                    break;
+                }
+                case common_js_2.ContextType.TypeSigner: // TYPE_SIGNER (45)
+                    nodeStack.push({ type: "context", context: "Signer" });
+                    break;
+                case common_js_2.ContextType.TypeClock:
+                    nodeStack.push({ type: "context", context: "Clock" });
+                    break;
+                case common_js_2.ContextType.TypeGuard:
+                    nodeStack.push({ type: "context", context: "Guard" });
+                    break;
+                case common_js_1.OperatorType.TypeQuery: {
+                    // TYPE_QUERY (40)
+                    const witnessByte = readByte();
+                    const identifier = readByte();
+                    const queryId = readU16();
+                    const queryInfo = (0, guard_ins_js_1.getGuardQueryInfo)(queryId);
+                    if (!queryInfo) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Query with ID ${queryId} not found`);
+                    }
+                    // Pop parameters from stack (in reverse order)
+                    const parameters = [];
+                    for (let i = 0; i < queryInfo.parameters.length; i++) {
+                        if (nodeStack.length === 0) {
+                            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient parameters for query ${queryInfo.name}`);
+                        }
+                        parameters.unshift(nodeStack.pop());
+                    }
+                    if (queryInfo.id === 1167 &&
+                        parameters[0].type === "identifier" && // 来自于table
+                        parameters[0]?.identifier != null) {
+                        const rep_item = table.find((item) => item.identifier === identifier &&
+                            !item.b_submission);
+                        const policy_item = table.find((item) => item.identifier ===
+                            parameters[0].identifier &&
+                            !item.b_submission);
+                        const repItemValueType = rep_item
+                            ? (0, common_js_1.parseValueType)(rep_item.value_type)
+                            : undefined;
+                        const policyItemValueType = policy_item
+                            ? (0, common_js_1.parseValueType)(policy_item.value_type)
+                            : undefined;
+                        if (rep_item &&
+                            policy_item &&
+                            repItemValueType === common_js_1.ValueType.Address &&
+                            policyItemValueType === common_js_1.ValueType.String) {
+                            if (rep_quote.has(rep_item.value)) {
+                                if (!rep_quote
+                                    .get(rep_item.value)
+                                    .includes(policy_item.value)) {
+                                    rep_quote
+                                        .get(rep_item.value)
+                                        .push(policy_item.value);
+                                }
+                            }
+                            else {
+                                rep_quote.set(rep_item.value, [
+                                    policy_item.value,
+                                ]);
+                            }
+                        }
+                    }
+                    nodeStack.push({
+                        type: "query",
+                        query: queryInfo.name,
+                        object: {
+                            identifier,
+                            ...(witnessByte !== common_js_2.ContextType.TypeConstant
+                                ? { convert_witness: witnessByte }
+                                : {}),
+                        },
+                        parameters,
+                    });
+                    break;
+                }
+                case common_js_1.OperatorType.TypeLogicEqual:
+                case common_js_1.OperatorType.TypeLogicAnd:
+                case common_js_1.OperatorType.TypeLogicOr:
+                case common_js_1.OperatorType.TypeLogicAsU256GreaterEqual:
+                case common_js_1.OperatorType.TypeLogicAsU256LesserEqual:
+                case common_js_1.OperatorType.TypeLogicAsU256Equal:
+                case common_js_1.OperatorType.TypeLogicAsU256Greater:
+                case common_js_1.OperatorType.TypeLogicAsU256Lesser:
+                case common_js_1.OperatorType.TypeStringContains:
+                case common_js_1.OperatorType.TypeStringNocaseContains:
+                case common_js_1.OperatorType.TypeStringNocaseEqual:
+                case common_js_1.OperatorType.TypeNumberAdd:
+                case common_js_1.OperatorType.TypeNumberSubtract:
+                case common_js_1.OperatorType.TypeNumberMultiply:
+                case common_js_1.OperatorType.TypeNumberDivide:
+                case common_js_1.OperatorType.TypeNumberMod: {
+                    const operandCount = readByte();
+                    const operands = [];
+                    // Pop operands from stack
+                    // Serialization pushes children in reverse order (right to left)
+                    // Popping gives us right to left, which matches original order
+                    for (let i = 0; i < operandCount; i++) {
+                        if (nodeStack.length === 0) {
+                            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operands for multi-operand operation`);
+                        }
+                        operands.push(nodeStack.pop());
+                    }
+                    const nodeProperty = getNodePropertyFromOpCode(opCode);
+                    nodeStack.push({
+                        type: nodeProperty,
+                        nodes: operands,
+                    });
+                    break;
+                }
+                case common_js_1.OperatorType.TypeLogicNot:
+                case common_js_1.OperatorType.TypeStringLength:
+                case common_js_1.OperatorType.TypeNumberAddress:
+                case common_js_1.OperatorType.TypeAddressNumber:
+                case common_js_1.OperatorType.TypeNumberString:
+                case common_js_1.OperatorType.TypeStringNumber:
+                case common_js_1.OperatorType.TypeSafeU8:
+                case common_js_1.OperatorType.TypeSafeU16:
+                case common_js_1.OperatorType.TypeSafeU32:
+                case common_js_1.OperatorType.TypeSafeU64:
+                case common_js_1.OperatorType.TypeSafeU128:
+                case common_js_1.OperatorType.TypeSafeU256:
+                case common_js_1.OperatorType.TypedValueType:
+                case common_js_1.OperatorType.TypedValueVecLength: {
+                    if (nodeStack.length === 0) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operand for single-operand operation`);
+                    }
+                    const operand = nodeStack.pop();
+                    const nodeProperty = getNodePropertyFromOpCode(opCode);
+                    nodeStack.push({
+                        type: nodeProperty,
+                        node: operand,
+                    });
+                    break;
+                }
+                case common_js_1.OperatorType.TypeStringIndexof:
+                case common_js_1.OperatorType.TypeStringNocaseIndexof:
+                case common_js_1.OperatorType.TypedValueVecIndexOf_Bool:
+                case common_js_1.OperatorType.TypedValueVecIndexOf_Address:
+                case common_js_1.OperatorType.TypedValueVecIndexOf_String:
+                case common_js_1.OperatorType.TypedValueVecIndexOf_StringNoCase:
+                case common_js_1.OperatorType.TypedValueVecIndexOf_Number: {
+                    const orderByte = readByte();
+                    const order = orderByte === 0 ? "forward" : "backward";
+                    if (nodeStack.length < 2) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operands for two-operand operation`);
+                    }
+                    // Pop in reverse order of serialization
+                    const nodeLeft = nodeStack.pop();
+                    const nodeRight = nodeStack.pop();
+                    const nodeProperty = getNodePropertyFromOpCode(opCode);
+                    nodeStack.push({
+                        type: nodeProperty,
+                        nodeLeft,
+                        nodeRight,
+                        order,
+                    });
+                    break;
+                }
+                default:
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Unknown opcode ${opCode}`);
             }
-            operands.push(nodeStack.pop());
-          }
-          const nodeProperty = getNodePropertyFromOpCode(opCode);
-          nodeStack.push({
-            type: nodeProperty,
-            nodes: operands
-          });
-          break;
         }
-        case import_common.OperatorType.TypeLogicNot:
-        case import_common.OperatorType.TypeStringLength:
-        case import_common.OperatorType.TypeNumberAddress:
-        case import_common.OperatorType.TypeAddressNumber:
-        case import_common.OperatorType.TypeNumberString:
-        case import_common.OperatorType.TypeStringNumber:
-        case import_common.OperatorType.TypeSafeU8:
-        case import_common.OperatorType.TypeSafeU16:
-        case import_common.OperatorType.TypeSafeU32:
-        case import_common.OperatorType.TypeSafeU64:
-        case import_common.OperatorType.TypeSafeU128:
-        case import_common.OperatorType.TypeSafeU256:
-        case import_common.OperatorType.TypedValueType:
-        case import_common.OperatorType.TypedValueVecLength: {
-          if (nodeStack.length === 0) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `restoreNodeFromOutput: Insufficient operand for single-operand operation`
-            );
-          }
-          const operand = nodeStack.pop();
-          const nodeProperty = getNodePropertyFromOpCode(opCode);
-          nodeStack.push({
-            type: nodeProperty,
-            node: operand
-          });
-          break;
+        // The root node should be the only element left in the stack
+        if (nodeStack.length !== 1) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Expected 1 node in stack, found ${nodeStack.length}`);
         }
-        case import_common.OperatorType.TypeStringIndexof:
-        case import_common.OperatorType.TypeStringNocaseIndexof:
-        case import_common.OperatorType.TypedValueVecIndexOf_Bool:
-        case import_common.OperatorType.TypedValueVecIndexOf_Address:
-        case import_common.OperatorType.TypedValueVecIndexOf_String:
-        case import_common.OperatorType.TypedValueVecIndexOf_StringNoCase:
-        case import_common.OperatorType.TypedValueVecIndexOf_Number: {
-          const orderByte = readByte();
-          const order = orderByte === 0 ? "forward" : "backward";
-          if (nodeStack.length < 2) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `restoreNodeFromOutput: Insufficient operands for two-operand operation`
-            );
-          }
-          const nodeLeft = nodeStack.pop();
-          const nodeRight = nodeStack.pop();
-          const nodeProperty = getNodePropertyFromOpCode(opCode);
-          nodeStack.push({
-            type: nodeProperty,
-            nodeLeft,
-            nodeRight,
-            order
-          });
-          break;
-        }
-        default:
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `restoreNodeFromOutput: Unknown opcode ${opCode}`
-          );
-      }
+        return {
+            root: nodeStack[0],
+            rep_quote,
+        };
     }
-    if (nodeStack.length !== 1) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `restoreNodeFromOutput: Expected 1 node in stack, found ${nodeStack.length}`
-      );
+    catch (error) {
+        throw new Error(`restoreNodeFromOutput: Failed to restore GuardNode from output: ${error.message}`);
     }
-    return {
-      root: nodeStack[0],
-      rep_quote
-    };
-  } catch (error) {
-    throw new Error(
-      `restoreNodeFromOutput: Failed to restore GuardNode from output: ${error.message}`
-    );
-  }
 };
+exports.restoreNodeFromOutput = restoreNodeFromOutput;
+// Helper function to get node property from opcode
 const getNodePropertyFromOpCode = (opCode) => {
-  switch (opCode) {
-    case import_common.OperatorType.TypeLogicEqual:
-      return "logic_equal";
-    case import_common.OperatorType.TypeLogicAnd:
-      return "logic_and";
-    case import_common.OperatorType.TypeLogicOr:
-      return "logic_or";
-    case import_common.OperatorType.TypeLogicAsU256GreaterEqual:
-      return "logic_as_u256_greater_or_equal";
-    case import_common.OperatorType.TypeLogicAsU256LesserEqual:
-      return "logic_as_u256_lesser_or_equal";
-    case import_common.OperatorType.TypeLogicAsU256Equal:
-      return "logic_as_u256_equal";
-    case import_common.OperatorType.TypeLogicAsU256Greater:
-      return "logic_as_u256_greater";
-    case import_common.OperatorType.TypeLogicAsU256Lesser:
-      return "logic_as_u256_lesser";
-    case import_common.OperatorType.TypeStringContains:
-      return "logic_string_contains";
-    case import_common.OperatorType.TypeStringNocaseContains:
-      return "logic_string_nocase_contains";
-    case import_common.OperatorType.TypeStringNocaseEqual:
-      return "logic_string_nocase_equal";
-    case import_common.OperatorType.TypeNumberAdd:
-      return "calc_number_add";
-    case import_common.OperatorType.TypeNumberSubtract:
-      return "calc_number_subtract";
-    case import_common.OperatorType.TypeNumberMultiply:
-      return "calc_number_multiply";
-    case import_common.OperatorType.TypeNumberDivide:
-      return "calc_number_divide";
-    case import_common.OperatorType.TypeNumberMod:
-      return "calc_number_mod";
-    case import_common.OperatorType.TypeLogicNot:
-      return "logic_not";
-    case import_common.OperatorType.TypeStringLength:
-      return "calc_string_length";
-    case import_common.OperatorType.TypeNumberAddress:
-      return "convert_number_address";
-    case import_common.OperatorType.TypeAddressNumber:
-      return "convert_address_number";
-    case import_common.OperatorType.TypeNumberString:
-      return "convert_number_string";
-    case import_common.OperatorType.TypeStringNumber:
-      return "convert_string_number";
-    case import_common.OperatorType.TypeSafeU8:
-      return "convert_safe_u8";
-    case import_common.OperatorType.TypeSafeU16:
-      return "convert_safe_u16";
-    case import_common.OperatorType.TypeSafeU32:
-      return "convert_safe_u32";
-    case import_common.OperatorType.TypeSafeU64:
-      return "convert_safe_u64";
-    case import_common.OperatorType.TypeSafeU128:
-      return "convert_safe_u128";
-    case import_common.OperatorType.TypeSafeU256:
-      return "convert_safe_u256";
-    case import_common.OperatorType.TypedValueType:
-      return "value_type";
-    case import_common.OperatorType.TypedValueVecLength:
-      return "vec_length";
-    case import_common.OperatorType.TypeStringIndexof:
-      return "calc_string_indexof";
-    case import_common.OperatorType.TypeStringNocaseIndexof:
-      return "calc_string_nocase_indexof";
-    case import_common.OperatorType.TypedValueVecIndexOf_Bool:
-      return "vec_indexof_bool";
-    case import_common.OperatorType.TypedValueVecIndexOf_Address:
-      return "vec_indexof_address";
-    case import_common.OperatorType.TypedValueVecIndexOf_String:
-      return "vec_indexof_string";
-    case import_common.OperatorType.TypedValueVecIndexOf_StringNoCase:
-      return "vec_indexof_string_nocase";
-    case import_common.OperatorType.TypedValueVecIndexOf_Number:
-      return "vec_indexof_number";
-    default:
-      return "unknown";
-  }
+    switch (opCode) {
+        case common_js_1.OperatorType.TypeLogicEqual:
+            return "logic_equal";
+        case common_js_1.OperatorType.TypeLogicAnd:
+            return "logic_and";
+        case common_js_1.OperatorType.TypeLogicOr:
+            return "logic_or";
+        case common_js_1.OperatorType.TypeLogicAsU256GreaterEqual:
+            return "logic_as_u256_greater_or_equal";
+        case common_js_1.OperatorType.TypeLogicAsU256LesserEqual:
+            return "logic_as_u256_lesser_or_equal";
+        case common_js_1.OperatorType.TypeLogicAsU256Equal:
+            return "logic_as_u256_equal";
+        case common_js_1.OperatorType.TypeLogicAsU256Greater:
+            return "logic_as_u256_greater";
+        case common_js_1.OperatorType.TypeLogicAsU256Lesser:
+            return "logic_as_u256_lesser";
+        case common_js_1.OperatorType.TypeStringContains:
+            return "logic_string_contains";
+        case common_js_1.OperatorType.TypeStringNocaseContains:
+            return "logic_string_nocase_contains";
+        case common_js_1.OperatorType.TypeStringNocaseEqual:
+            return "logic_string_nocase_equal";
+        case common_js_1.OperatorType.TypeNumberAdd:
+            return "calc_number_add";
+        case common_js_1.OperatorType.TypeNumberSubtract:
+            return "calc_number_subtract";
+        case common_js_1.OperatorType.TypeNumberMultiply:
+            return "calc_number_multiply";
+        case common_js_1.OperatorType.TypeNumberDivide:
+            return "calc_number_divide";
+        case common_js_1.OperatorType.TypeNumberMod:
+            return "calc_number_mod";
+        case common_js_1.OperatorType.TypeLogicNot:
+            return "logic_not";
+        case common_js_1.OperatorType.TypeStringLength:
+            return "calc_string_length";
+        case common_js_1.OperatorType.TypeNumberAddress:
+            return "convert_number_address";
+        case common_js_1.OperatorType.TypeAddressNumber:
+            return "convert_address_number";
+        case common_js_1.OperatorType.TypeNumberString:
+            return "convert_number_string";
+        case common_js_1.OperatorType.TypeStringNumber:
+            return "convert_string_number";
+        case common_js_1.OperatorType.TypeSafeU8:
+            return "convert_safe_u8";
+        case common_js_1.OperatorType.TypeSafeU16:
+            return "convert_safe_u16";
+        case common_js_1.OperatorType.TypeSafeU32:
+            return "convert_safe_u32";
+        case common_js_1.OperatorType.TypeSafeU64:
+            return "convert_safe_u64";
+        case common_js_1.OperatorType.TypeSafeU128:
+            return "convert_safe_u128";
+        case common_js_1.OperatorType.TypeSafeU256:
+            return "convert_safe_u256";
+        case common_js_1.OperatorType.TypedValueType:
+            return "value_type";
+        case common_js_1.OperatorType.TypedValueVecLength:
+            return "vec_length";
+        case common_js_1.OperatorType.TypeStringIndexof:
+            return "calc_string_indexof";
+        case common_js_1.OperatorType.TypeStringNocaseIndexof:
+            return "calc_string_nocase_indexof";
+        case common_js_1.OperatorType.TypedValueVecIndexOf_Bool:
+            return "vec_indexof_bool";
+        case common_js_1.OperatorType.TypedValueVecIndexOf_Address:
+            return "vec_indexof_address";
+        case common_js_1.OperatorType.TypedValueVecIndexOf_String:
+            return "vec_indexof_string";
+        case common_js_1.OperatorType.TypedValueVecIndexOf_StringNoCase:
+            return "vec_indexof_string_nocase";
+        case common_js_1.OperatorType.TypedValueVecIndexOf_Number:
+            return "vec_indexof_number";
+        default:
+            return "unknown";
+    }
 };
+//# sourceMappingURL=util.js.map