wowok 2.1.9 → 2.1.12

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

@@ -1,646 +1,623 @@
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
 import { bcs } from "../../bcs/index.js";
-import {
-  isValueTypeNumber,
-  OperatorType,
-  ValueType,
-  parseValueType
-} from "../common.js";
+import { isValueTypeNumber, OperatorType, ValueType, parseValueType, } from "../common.js";
 import { ContextType, MAX_ENV_PERMISSION_GUARD_COUNT } from "../common.js";
 import { W_ERROR, WErrors } from "../exception.js";
 import { Config, GetAccountOrMark_Address } from "../local/index.js";
 import { LocalMark } from "../local/local.js";
 import { GUARDQUERY, getGuardQueryInfo } from "./guard-ins.js";
-const getCallEnvAccount = async (env) => {
-  const acc = await GetAccountOrMark_Address({
-    name_or_address: env.account || ""
-  });
-  if (!acc) {
-    W_ERROR(WErrors.InvalidParam, `account ${env.account} not found`);
-  }
-  env.account = acc;
-  return acc;
+export const getCallEnvAccount = async (env) => {
+    const acc = await GetAccountOrMark_Address({
+        name_or_address: env.account || "",
+    });
+    if (!acc) {
+        W_ERROR(WErrors.InvalidParam, `account ${env.account} not found`);
+    }
+    env.account = acc;
+    return acc;
 };
 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 Config.Instance().network_get(env?.network);
-  const acc = await getCallEnvAccount(env);
-  if (env?.permission_guard && env.permission_guard?.length > 0) {
-    const guards = await 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)
-      );
-      W_ERROR(
-        WErrors.InvalidParam,
-        `permission_guard not found: ${notFoundGuards.join(", ")}`
-      );
-    }
-    env.permission_guard = [...guards];
-    if (env.permission_guard.length > MAX_ENV_PERMISSION_GUARD_COUNT) {
-      W_ERROR(
-        WErrors.InvalidParam,
-        `permission_guard length ${env.permission_guard.length} exceeds ${MAX_ENV_PERMISSION_GUARD_COUNT}`
-      );
+export const resolveCallEnv = async (env) => {
+    env.network = await Config.Instance().network_get(env?.network);
+    const acc = await getCallEnvAccount(env);
+    // 去重处理
+    if (env?.permission_guard && env.permission_guard?.length > 0) {
+        const guards = await 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));
+            W_ERROR(WErrors.InvalidParam, `permission_guard not found: ${notFoundGuards.join(", ")}`);
+        }
+        env.permission_guard = [...guards];
+        if (env.permission_guard.length > MAX_ENV_PERMISSION_GUARD_COUNT) {
+            W_ERROR(WErrors.InvalidParam, `permission_guard length ${env.permission_guard.length} exceeds ${MAX_ENV_PERMISSION_GUARD_COUNT}`);
+        }
     }
-  }
-  if (env?.referrer) {
-    const r = await GetAccountOrMark_Address({
-      name_or_address: env.referrer || ""
-    });
-    if (r) {
-      env.referrer = r;
-    } else {
-      W_ERROR(WErrors.InvalidParam, `referrer ${env.referrer} not found`);
+    if (env?.referrer) {
+        const r = await GetAccountOrMark_Address({
+            name_or_address: env.referrer || "",
+        });
+        if (r) {
+            env.referrer = r;
+        }
+        else {
+            W_ERROR(WErrors.InvalidParam, `referrer ${env.referrer} not found`);
+        }
     }
-  }
-  return acc;
+    return acc;
 };
-const checkType = (type, type_required, node) => {
-  if (type_required === "variable") {
-    return;
-  } else if (type_required === "number") {
-    if (isValueTypeNumber(type) || type === ContextType.TypeClock || type === ValueType.Value) {
-      return;
+// ================================================
+// 从output和table恢复GuardNode的函数
+// ================================================
+export const checkType = (type, type_required, node) => {
+    if (type_required === "variable") {
+        return;
+    }
+    else if (type_required === "number") {
+        if (isValueTypeNumber(type) ||
+            type === ContextType.TypeClock ||
+            type === ValueType.Value) {
+            return;
+        }
     }
-  } else if (type_required === ValueType.Address) {
-    if (type === ContextType.TypeSigner || type === ContextType.TypeGuard || type === ValueType.Value) {
-      return;
+    else if (type_required === ValueType.Address) {
+        if (type === ContextType.TypeSigner ||
+            type === ContextType.TypeGuard ||
+            type === ValueType.Value) {
+            return;
+        }
+    }
+    else if (type === ValueType.Value) {
+        // Value 是动态类型，可以匹配任何具体类型
+        return;
     }
-  } else if (type === ValueType.Value) {
-    return;
-  } else if (type_required === ValueType.Value) {
-    return;
-  } else if (type_required === "vec_number") {
-    if (type === ValueType.VecU8 || type === ValueType.VecU16 || type === ValueType.VecU32 || type === ValueType.VecU64 || type === ValueType.VecU128 || type === ValueType.VecU256) {
-      return;
+    else if (type_required === ValueType.Value) {
+        // 任何类型都可以赋值给 Value 类型
+        return;
     }
-  } else if (type_required === "vec") {
-    if (type === ValueType.VecBool || type === ValueType.VecAddress || type === ValueType.VecString || type === ValueType.VecU8 || type === ValueType.VecU16 || type === ValueType.VecU32 || type === ValueType.VecU64 || type === ValueType.VecU128 || type === ValueType.VecU256) {
-      return;
+    else if (type_required === "vec_number") {
+        if (type === ValueType.VecU8 ||
+            type === ValueType.VecU16 ||
+            type === ValueType.VecU32 ||
+            type === ValueType.VecU64 ||
+            type === ValueType.VecU128 ||
+            type === ValueType.VecU256) {
+            return;
+        }
+    }
+    else if (type_required === "vec") {
+        if (type === ValueType.VecBool ||
+            type === ValueType.VecAddress ||
+            type === ValueType.VecString ||
+            type === ValueType.VecU8 ||
+            type === ValueType.VecU16 ||
+            type === ValueType.VecU32 ||
+            type === ValueType.VecU64 ||
+            type === ValueType.VecU128 ||
+            type === ValueType.VecU256) {
+            return;
+        }
+    }
+    if (type !== type_required) {
+        W_ERROR(WErrors.InvalidParam, `checkType: ${type} require type: ${type_required} with node: ${JSON.stringify(node)}`);
     }
-  }
-  if (type !== type_required) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `checkType: ${type} require type: ${type_required} with node: ${JSON.stringify(node)}`
-    );
-  }
 };
+// 从链上获取数据，就不用再checkType
 const parseNode = (parserState) => {
-  if (parserState.currentPosition >= parserState.output.length) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      "parseNode: Unexpected end of output while parsing node"
-    );
-  }
-  const opCode = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  switch (opCode) {
-    case ContextType.TypeConstant:
-      if (parserState.currentPosition >= parserState.output.length) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          "parseNode: Missing identifier after TypeConstant opcode"
-        );
-      }
-      const identifierByte = parserState.output[parserState.currentPosition];
-      parserState.currentPosition++;
-      return { type: "identifier", identifier: identifierByte };
-    case OperatorType.TypeQuery:
-      return parseQueryNode(parserState);
-    case OperatorType.TypeLogicAsU256GreaterEqual:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_as_u256_greater_or_equal"
-      );
-    case OperatorType.TypeLogicAsU256LesserEqual:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_as_u256_lesser_or_equal"
-      );
-    case OperatorType.TypeLogicAsU256Equal:
-      return parseMultiOperandNode(parserState, "logic_as_u256_equal");
-    case OperatorType.TypeLogicAsU256Greater:
-      return parseMultiOperandNode(parserState, "logic_as_u256_greater");
-    case OperatorType.TypeLogicAsU256Lesser:
-      return parseMultiOperandNode(parserState, "logic_as_u256_lesser");
-    case OperatorType.TypeLogicEqual:
-      return parseMultiOperandNode(parserState, "logic_equal");
-    case OperatorType.TypeLogicAnd:
-      return parseMultiOperandNode(parserState, "logic_and");
-    case OperatorType.TypeLogicOr:
-      return parseMultiOperandNode(parserState, "logic_or");
-    case OperatorType.TypeStringContains:
-      return parseMultiOperandNode(parserState, "logic_string_contains");
-    case OperatorType.TypeStringNocaseContains:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_string_nocase_contains"
-      );
-    case OperatorType.TypeStringNocaseEqual:
-      return parseMultiOperandNode(
-        parserState,
-        "logic_string_nocase_equal"
-      );
-    case OperatorType.TypeNumberAdd:
-      return parseMultiOperandNode(parserState, "calc_number_add");
-    case OperatorType.TypeNumberSubtract:
-      return parseMultiOperandNode(parserState, "calc_number_subtract");
-    case OperatorType.TypeNumberMultiply:
-      return parseMultiOperandNode(parserState, "calc_number_multiply");
-    case OperatorType.TypeNumberDivide:
-      return parseMultiOperandNode(parserState, "calc_number_divide");
-    case OperatorType.TypeNumberMod:
-      return parseMultiOperandNode(parserState, "calc_number_mod");
-    case OperatorType.TypeLogicNot:
-      return parseSingleOperandNode(parserState, "logic_not");
-    case OperatorType.TypeStringLength:
-      return parseSingleOperandNode(parserState, "calc_string_length");
-    case OperatorType.TypeNumberAddress:
-      return parseSingleOperandNode(
-        parserState,
-        "convert_number_address"
-      );
-    case OperatorType.TypeAddressNumber:
-      return parseSingleOperandNode(
-        parserState,
-        "convert_address_number"
-      );
-    case OperatorType.TypeNumberString:
-      return parseSingleOperandNode(parserState, "convert_number_string");
-    case OperatorType.TypeStringNumber:
-      return parseSingleOperandNode(parserState, "convert_string_number");
-    /*case OperatorType.TypeStringLowercase:
-    	return parseSingleOperandNode(
-    		parserState,
-    		"convert_string_lowercase",
-    	);*/
-    case OperatorType.TypeSafeU8:
-      return parseSingleOperandNode(parserState, "convert_safe_u8");
-    case OperatorType.TypeSafeU16:
-      return parseSingleOperandNode(parserState, "convert_safe_u16");
-    case OperatorType.TypeSafeU32:
-      return parseSingleOperandNode(parserState, "convert_safe_u32");
-    case OperatorType.TypeSafeU64:
-      return parseSingleOperandNode(parserState, "convert_safe_u64");
-    case OperatorType.TypeSafeU128:
-      return parseSingleOperandNode(parserState, "convert_safe_u128");
-    case OperatorType.TypeSafeU256:
-      return parseSingleOperandNode(parserState, "convert_safe_u256");
-    case OperatorType.TypeStringIndexof:
-      return parseTwoOperandNode(parserState, "calc_string_indexof");
-    case OperatorType.TypeStringNocaseIndexof:
-      return parseTwoOperandNode(
-        parserState,
-        "calc_string_nocase_indexof"
-      );
-    // typedValue 操作
-    case OperatorType.TypedValueType:
-      return parseSingleOperandNode(parserState, "value_type");
-    case OperatorType.TypedValueVecLength:
-      return parseSingleOperandNode(parserState, "vec_length");
-    case OperatorType.TypedValueVecContains_Bool:
-      return parseMultiOperandNode(parserState, "vec_contains_bool");
-    case OperatorType.TypedValueVecContains_Address:
-      return parseMultiOperandNode(parserState, "vec_contains_address");
-    case OperatorType.TypedValueVecContains_String:
-      return parseMultiOperandNode(parserState, "vec_contains_string");
-    case OperatorType.TypedValueVecContains_StringNoCase:
-      return parseMultiOperandNode(
-        parserState,
-        "vec_contains_string_nocase"
-      );
-    case OperatorType.TypedValueVecContains_Number:
-      return parseMultiOperandNode(parserState, "vec_contains_number");
-    case OperatorType.TypedValueVecIndexOf_Bool:
-      return parseTwoOperandNode(parserState, "vec_indexof_bool");
-    case OperatorType.TypedValueVecIndexOf_Address:
-      return parseTwoOperandNode(parserState, "vec_indexof_address");
-    case OperatorType.TypedValueVecIndexOf_String:
-      return parseTwoOperandNode(parserState, "vec_indexof_string");
-    case OperatorType.TypedValueVecIndexOf_StringNoCase:
-      return parseTwoOperandNode(
-        parserState,
-        "vec_indexof_string_nocase"
-      );
-    case OperatorType.TypedValueVecIndexOf_Number:
-      return parseTwoOperandNode(parserState, "vec_indexof_number");
-    case ContextType.TypeSigner:
-      return { type: "context", context: "Signer" };
-    case ContextType.TypeGuard:
-      return { type: "context", context: "Guard" };
-    case ContextType.TypeClock:
-      return { type: "context", context: "Clock" };
-    default:
-      throw new Error(`ParseGuardNode: Unknown opcode: ${opCode}`);
-  }
+    if (parserState.currentPosition >= parserState.output.length) {
+        W_ERROR(WErrors.InvalidParam, "parseNode: Unexpected end of output while parsing node");
+    }
+    const opCode = parserState.output[parserState.currentPosition];
+    parserState.currentPosition++;
+    switch (opCode) {
+        case ContextType.TypeConstant: // TYPE_CONSTANT
+            if (parserState.currentPosition >= parserState.output.length) {
+                W_ERROR(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 OperatorType.TypeQuery: // QUERY TYPE
+            return parseQueryNode(parserState);
+        case OperatorType.TypeLogicAsU256GreaterEqual:
+            return parseMultiOperandNode(parserState, "logic_as_u256_greater_or_equal");
+        case OperatorType.TypeLogicAsU256LesserEqual:
+            return parseMultiOperandNode(parserState, "logic_as_u256_lesser_or_equal");
+        case OperatorType.TypeLogicAsU256Equal:
+            return parseMultiOperandNode(parserState, "logic_as_u256_equal");
+        case OperatorType.TypeLogicAsU256Greater:
+            return parseMultiOperandNode(parserState, "logic_as_u256_greater");
+        case OperatorType.TypeLogicAsU256Lesser:
+            return parseMultiOperandNode(parserState, "logic_as_u256_lesser");
+        case OperatorType.TypeLogicEqual:
+            return parseMultiOperandNode(parserState, "logic_equal");
+        case OperatorType.TypeLogicAnd:
+            return parseMultiOperandNode(parserState, "logic_and");
+        case OperatorType.TypeLogicOr:
+            return parseMultiOperandNode(parserState, "logic_or");
+        case OperatorType.TypeStringContains:
+            return parseMultiOperandNode(parserState, "logic_string_contains");
+        case OperatorType.TypeStringNocaseContains:
+            return parseMultiOperandNode(parserState, "logic_string_nocase_contains");
+        case OperatorType.TypeStringNocaseEqual:
+            return parseMultiOperandNode(parserState, "logic_string_nocase_equal");
+        case OperatorType.TypeNumberAdd:
+            return parseMultiOperandNode(parserState, "calc_number_add");
+        case OperatorType.TypeNumberSubtract:
+            return parseMultiOperandNode(parserState, "calc_number_subtract");
+        case OperatorType.TypeNumberMultiply:
+            return parseMultiOperandNode(parserState, "calc_number_multiply");
+        case OperatorType.TypeNumberDivide:
+            return parseMultiOperandNode(parserState, "calc_number_divide");
+        case OperatorType.TypeNumberMod:
+            return parseMultiOperandNode(parserState, "calc_number_mod");
+        case OperatorType.TypeLogicNot:
+            return parseSingleOperandNode(parserState, "logic_not");
+        case OperatorType.TypeStringLength:
+            return parseSingleOperandNode(parserState, "calc_string_length");
+        case OperatorType.TypeNumberAddress:
+            return parseSingleOperandNode(parserState, "convert_number_address");
+        case OperatorType.TypeAddressNumber:
+            return parseSingleOperandNode(parserState, "convert_address_number");
+        case OperatorType.TypeNumberString:
+            return parseSingleOperandNode(parserState, "convert_number_string");
+        case OperatorType.TypeStringNumber:
+            return parseSingleOperandNode(parserState, "convert_string_number");
+        /*case OperatorType.TypeStringLowercase:
+            return parseSingleOperandNode(
+                parserState,
+                "convert_string_lowercase",
+            );*/
+        case OperatorType.TypeSafeU8:
+            return parseSingleOperandNode(parserState, "convert_safe_u8");
+        case OperatorType.TypeSafeU16:
+            return parseSingleOperandNode(parserState, "convert_safe_u16");
+        case OperatorType.TypeSafeU32:
+            return parseSingleOperandNode(parserState, "convert_safe_u32");
+        case OperatorType.TypeSafeU64:
+            return parseSingleOperandNode(parserState, "convert_safe_u64");
+        case OperatorType.TypeSafeU128:
+            return parseSingleOperandNode(parserState, "convert_safe_u128");
+        case OperatorType.TypeSafeU256:
+            return parseSingleOperandNode(parserState, "convert_safe_u256");
+        case OperatorType.TypeStringIndexof:
+            return parseTwoOperandNode(parserState, "calc_string_indexof");
+        case OperatorType.TypeStringNocaseIndexof:
+            return parseTwoOperandNode(parserState, "calc_string_nocase_indexof");
+        // typedValue 操作
+        case OperatorType.TypedValueType:
+            return parseSingleOperandNode(parserState, "value_type");
+        case OperatorType.TypedValueVecLength:
+            return parseSingleOperandNode(parserState, "vec_length");
+        case OperatorType.TypedValueVecContains_Bool:
+            return parseMultiOperandNode(parserState, "vec_contains_bool");
+        case OperatorType.TypedValueVecContains_Address:
+            return parseMultiOperandNode(parserState, "vec_contains_address");
+        case OperatorType.TypedValueVecContains_String:
+            return parseMultiOperandNode(parserState, "vec_contains_string");
+        case OperatorType.TypedValueVecContains_StringNoCase:
+            return parseMultiOperandNode(parserState, "vec_contains_string_nocase");
+        case OperatorType.TypedValueVecContains_Number:
+            return parseMultiOperandNode(parserState, "vec_contains_number");
+        case OperatorType.TypedValueVecIndexOf_Bool:
+            return parseTwoOperandNode(parserState, "vec_indexof_bool");
+        case OperatorType.TypedValueVecIndexOf_Address:
+            return parseTwoOperandNode(parserState, "vec_indexof_address");
+        case OperatorType.TypedValueVecIndexOf_String:
+            return parseTwoOperandNode(parserState, "vec_indexof_string");
+        case OperatorType.TypedValueVecIndexOf_StringNoCase:
+            return parseTwoOperandNode(parserState, "vec_indexof_string_nocase");
+        case OperatorType.TypedValueVecIndexOf_Number:
+            return parseTwoOperandNode(parserState, "vec_indexof_number");
+        case ContextType.TypeSigner:
+            return { type: "context", context: "Signer" };
+        case ContextType.TypeGuard:
+            return { type: "context", context: "Guard" };
+        case 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) {
-    W_ERROR(
-      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) {
+        W_ERROR(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) {
-    W_ERROR(
-      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) {
+        W_ERROR(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) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      "parseQueryNode: Missing witness byte after TypeQuery opcode"
-    );
-  }
-  const witnessByte = parserState.output[parserState.currentPosition];
-  parserState.currentPosition++;
-  if (parserState.currentPosition >= parserState.output.length) {
-    W_ERROR(
-      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) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      "parseQueryNode: Not enough bytes for query ID after object identifier"
-    );
-  }
-  const queryId = bcs.U16.parse(remainingBytes);
-  parserState.currentPosition += 2;
-  const query = GUARDQUERY.find((q) => q.id === queryId);
-  if (!query) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `parseQueryNode: Query with ID ${queryId} not found`
-    );
-  }
-  const queryInfo = getGuardQueryInfo(queryId);
-  if (!queryInfo) {
-    W_ERROR(
-      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 !== ContextType.TypeConstant ? { convert_witness: witnessByte } : {}
-    },
-    parameters
-  };
-  return node;
-};
-const restoreNodeFromOutput = (output, table) => {
-  try {
-    if (!output || output.length === 0) {
-      W_ERROR(
-        WErrors.InvalidParam,
-        "restoreNodeFromOutput: output is empty"
-      );
+    // Read the witness type (if present)
+    if (parserState.currentPosition >= parserState.output.length) {
+        W_ERROR(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) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          "readByte: Unexpected end of output"
-        );
-      }
-      return output[position++];
-    };
-    const readU16 = () => {
-      if (position + 2 > output.length) {
-        W_ERROR(
-          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) {
+        W_ERROR(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) {
+        W_ERROR(WErrors.InvalidParam, "parseQueryNode: Not enough bytes for query ID after object identifier");
+    }
+    // Use BCS deserialization to read the u16 query ID
+    const queryId = bcs.U16.parse(remainingBytes);
+    parserState.currentPosition += 2;
+    // Find the query definition
+    const query = GUARDQUERY.find((q) => q.id === queryId);
+    if (!query) {
+        W_ERROR(WErrors.InvalidParam, `parseQueryNode: Query with ID ${queryId} not found`);
+    }
+    // Get full query info using the name
+    const queryInfo = getGuardQueryInfo(queryId);
+    if (!queryInfo) {
+        W_ERROR(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 !== ContextType.TypeConstant
+                ? { convert_witness: witnessByte }
+                : {}),
+        },
+        parameters,
     };
-    while (position < output.length) {
-      const opCode = readByte();
-      switch (opCode) {
-        case 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
+export const restoreNodeFromOutput = (output, table) => {
+    try {
+        // Validate output format
+        if (!output || output.length === 0) {
+            W_ERROR(WErrors.InvalidParam, "restoreNodeFromOutput: output is empty");
         }
-        case ContextType.TypeSigner:
-          nodeStack.push({ type: "context", context: "Signer" });
-          break;
-        case ContextType.TypeClock:
-          nodeStack.push({ type: "context", context: "Clock" });
-          break;
-        case ContextType.TypeGuard:
-          nodeStack.push({ type: "context", context: "Guard" });
-          break;
-        case OperatorType.TypeQuery: {
-          const witnessByte = readByte();
-          const identifier = readByte();
-          const queryId = readU16();
-          const queryInfo = getGuardQueryInfo(queryId);
-          if (!queryInfo) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `restoreNodeFromOutput: Query with ID ${queryId} not found`
-            );
-          }
-          const parameters = [];
-          for (let i = 0; i < queryInfo.parameters.length; i++) {
-            if (nodeStack.length === 0) {
-              W_ERROR(
-                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) {
+                W_ERROR(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 ? parseValueType(rep_item.value_type) : void 0;
-            const policyItemValueType = policy_item ? parseValueType(policy_item.value_type) : void 0;
-            if (rep_item && policy_item && repItemValueType === ValueType.Address && policyItemValueType === 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);
+            return output[position++];
+        };
+        // Helper function to read a u16 (little-endian)
+        const readU16 = () => {
+            if (position + 2 > output.length) {
+                W_ERROR(WErrors.InvalidParam, "readU16: Insufficient bytes for u16");
+            }
+            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 ContextType.TypeConstant: {
+                    // TYPE_CONSTANT (48)
+                    const identifier = readByte();
+                    nodeStack.push({ type: "identifier", identifier });
+                    break;
+                }
+                case ContextType.TypeSigner: // TYPE_SIGNER (45)
+                    nodeStack.push({ type: "context", context: "Signer" });
+                    break;
+                case ContextType.TypeClock:
+                    nodeStack.push({ type: "context", context: "Clock" });
+                    break;
+                case ContextType.TypeGuard:
+                    nodeStack.push({ type: "context", context: "Guard" });
+                    break;
+                case OperatorType.TypeQuery: {
+                    // TYPE_QUERY (40)
+                    const witnessByte = readByte();
+                    const identifier = readByte();
+                    const queryId = readU16();
+                    const queryInfo = getGuardQueryInfo(queryId);
+                    if (!queryInfo) {
+                        W_ERROR(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) {
+                            W_ERROR(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
+                            ? parseValueType(rep_item.value_type)
+                            : undefined;
+                        const policyItemValueType = policy_item
+                            ? parseValueType(policy_item.value_type)
+                            : undefined;
+                        if (rep_item &&
+                            policy_item &&
+                            repItemValueType === ValueType.Address &&
+                            policyItemValueType === 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 !== ContextType.TypeConstant
+                                ? { convert_witness: witnessByte }
+                                : {}),
+                        },
+                        parameters,
+                    });
+                    break;
+                }
+                case OperatorType.TypeLogicEqual:
+                case OperatorType.TypeLogicAnd:
+                case OperatorType.TypeLogicOr:
+                case OperatorType.TypeLogicAsU256GreaterEqual:
+                case OperatorType.TypeLogicAsU256LesserEqual:
+                case OperatorType.TypeLogicAsU256Equal:
+                case OperatorType.TypeLogicAsU256Greater:
+                case OperatorType.TypeLogicAsU256Lesser:
+                case OperatorType.TypeStringContains:
+                case OperatorType.TypeStringNocaseContains:
+                case OperatorType.TypeStringNocaseEqual:
+                case OperatorType.TypeNumberAdd:
+                case OperatorType.TypeNumberSubtract:
+                case OperatorType.TypeNumberMultiply:
+                case OperatorType.TypeNumberDivide:
+                case 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) {
+                            W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operands for multi-operand operation`);
+                        }
+                        operands.push(nodeStack.pop());
+                    }
+                    const nodeProperty = getNodePropertyFromOpCode(opCode);
+                    nodeStack.push({
+                        type: nodeProperty,
+                        nodes: operands,
+                    });
+                    break;
                 }
-              } else {
-                rep_quote.set(rep_item.value, [
-                  policy_item.value
-                ]);
-              }
+                case OperatorType.TypeLogicNot:
+                case OperatorType.TypeStringLength:
+                case OperatorType.TypeNumberAddress:
+                case OperatorType.TypeAddressNumber:
+                case OperatorType.TypeNumberString:
+                case OperatorType.TypeStringNumber:
+                case OperatorType.TypeSafeU8:
+                case OperatorType.TypeSafeU16:
+                case OperatorType.TypeSafeU32:
+                case OperatorType.TypeSafeU64:
+                case OperatorType.TypeSafeU128:
+                case OperatorType.TypeSafeU256:
+                case OperatorType.TypedValueType:
+                case OperatorType.TypedValueVecLength: {
+                    if (nodeStack.length === 0) {
+                        W_ERROR(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 OperatorType.TypeStringIndexof:
+                case OperatorType.TypeStringNocaseIndexof:
+                case OperatorType.TypedValueVecIndexOf_Bool:
+                case OperatorType.TypedValueVecIndexOf_Address:
+                case OperatorType.TypedValueVecIndexOf_String:
+                case OperatorType.TypedValueVecIndexOf_StringNoCase:
+                case OperatorType.TypedValueVecIndexOf_Number: {
+                    const orderByte = readByte();
+                    const order = orderByte === 0 ? "forward" : "backward";
+                    if (nodeStack.length < 2) {
+                        W_ERROR(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:
+                    W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Unknown opcode ${opCode}`);
             }
-          }
-          nodeStack.push({
-            type: "query",
-            query: queryInfo.name,
-            object: {
-              identifier,
-              ...witnessByte !== ContextType.TypeConstant ? { convert_witness: witnessByte } : {}
-            },
-            parameters
-          });
-          break;
         }
+        // The root node should be the only element left in the stack
+        if (nodeStack.length !== 1) {
+            W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Expected 1 node in stack, found ${nodeStack.length}`);
+        }
+        return {
+            root: nodeStack[0],
+            rep_quote,
+        };
+    }
+    catch (error) {
+        throw new Error(`restoreNodeFromOutput: Failed to restore GuardNode from output: ${error.message}`);
+    }
+};
+// Helper function to get node property from opcode
+const getNodePropertyFromOpCode = (opCode) => {
+    switch (opCode) {
         case OperatorType.TypeLogicEqual:
+            return "logic_equal";
         case OperatorType.TypeLogicAnd:
+            return "logic_and";
         case OperatorType.TypeLogicOr:
+            return "logic_or";
         case OperatorType.TypeLogicAsU256GreaterEqual:
+            return "logic_as_u256_greater_or_equal";
         case OperatorType.TypeLogicAsU256LesserEqual:
+            return "logic_as_u256_lesser_or_equal";
         case OperatorType.TypeLogicAsU256Equal:
+            return "logic_as_u256_equal";
         case OperatorType.TypeLogicAsU256Greater:
+            return "logic_as_u256_greater";
         case OperatorType.TypeLogicAsU256Lesser:
+            return "logic_as_u256_lesser";
         case OperatorType.TypeStringContains:
+            return "logic_string_contains";
         case OperatorType.TypeStringNocaseContains:
+            return "logic_string_nocase_contains";
         case OperatorType.TypeStringNocaseEqual:
+            return "logic_string_nocase_equal";
         case OperatorType.TypeNumberAdd:
+            return "calc_number_add";
         case OperatorType.TypeNumberSubtract:
+            return "calc_number_subtract";
         case OperatorType.TypeNumberMultiply:
+            return "calc_number_multiply";
         case OperatorType.TypeNumberDivide:
-        case OperatorType.TypeNumberMod: {
-          const operandCount = readByte();
-          const operands = [];
-          for (let i = 0; i < operandCount; i++) {
-            if (nodeStack.length === 0) {
-              W_ERROR(
-                WErrors.InvalidParam,
-                `restoreNodeFromOutput: Insufficient operands for multi-operand operation`
-              );
-            }
-            operands.push(nodeStack.pop());
-          }
-          const nodeProperty = getNodePropertyFromOpCode(opCode);
-          nodeStack.push({
-            type: nodeProperty,
-            nodes: operands
-          });
-          break;
-        }
+            return "calc_number_divide";
+        case OperatorType.TypeNumberMod:
+            return "calc_number_mod";
         case OperatorType.TypeLogicNot:
+            return "logic_not";
         case OperatorType.TypeStringLength:
+            return "calc_string_length";
         case OperatorType.TypeNumberAddress:
+            return "convert_number_address";
         case OperatorType.TypeAddressNumber:
+            return "convert_address_number";
         case OperatorType.TypeNumberString:
+            return "convert_number_string";
         case OperatorType.TypeStringNumber:
+            return "convert_string_number";
         case OperatorType.TypeSafeU8:
+            return "convert_safe_u8";
         case OperatorType.TypeSafeU16:
+            return "convert_safe_u16";
         case OperatorType.TypeSafeU32:
+            return "convert_safe_u32";
         case OperatorType.TypeSafeU64:
+            return "convert_safe_u64";
         case OperatorType.TypeSafeU128:
+            return "convert_safe_u128";
         case OperatorType.TypeSafeU256:
+            return "convert_safe_u256";
         case OperatorType.TypedValueType:
-        case OperatorType.TypedValueVecLength: {
-          if (nodeStack.length === 0) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `restoreNodeFromOutput: Insufficient operand for single-operand operation`
-            );
-          }
-          const operand = nodeStack.pop();
-          const nodeProperty = getNodePropertyFromOpCode(opCode);
-          nodeStack.push({
-            type: nodeProperty,
-            node: operand
-          });
-          break;
-        }
+            return "value_type";
+        case OperatorType.TypedValueVecLength:
+            return "vec_length";
         case OperatorType.TypeStringIndexof:
+            return "calc_string_indexof";
         case OperatorType.TypeStringNocaseIndexof:
+            return "calc_string_nocase_indexof";
         case OperatorType.TypedValueVecIndexOf_Bool:
+            return "vec_indexof_bool";
         case OperatorType.TypedValueVecIndexOf_Address:
+            return "vec_indexof_address";
         case OperatorType.TypedValueVecIndexOf_String:
+            return "vec_indexof_string";
         case OperatorType.TypedValueVecIndexOf_StringNoCase:
-        case OperatorType.TypedValueVecIndexOf_Number: {
-          const orderByte = readByte();
-          const order = orderByte === 0 ? "forward" : "backward";
-          if (nodeStack.length < 2) {
-            W_ERROR(
-              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;
-        }
+            return "vec_indexof_string_nocase";
+        case OperatorType.TypedValueVecIndexOf_Number:
+            return "vec_indexof_number";
         default:
-          W_ERROR(
-            WErrors.InvalidParam,
-            `restoreNodeFromOutput: Unknown opcode ${opCode}`
-          );
-      }
-    }
-    if (nodeStack.length !== 1) {
-      W_ERROR(
-        WErrors.InvalidParam,
-        `restoreNodeFromOutput: Expected 1 node in stack, found ${nodeStack.length}`
-      );
+            return "unknown";
     }
-    return {
-      root: nodeStack[0],
-      rep_quote
-    };
-  } catch (error) {
-    throw new Error(
-      `restoreNodeFromOutput: Failed to restore GuardNode from output: ${error.message}`
-    );
-  }
-};
-const getNodePropertyFromOpCode = (opCode) => {
-  switch (opCode) {
-    case OperatorType.TypeLogicEqual:
-      return "logic_equal";
-    case OperatorType.TypeLogicAnd:
-      return "logic_and";
-    case OperatorType.TypeLogicOr:
-      return "logic_or";
-    case OperatorType.TypeLogicAsU256GreaterEqual:
-      return "logic_as_u256_greater_or_equal";
-    case OperatorType.TypeLogicAsU256LesserEqual:
-      return "logic_as_u256_lesser_or_equal";
-    case OperatorType.TypeLogicAsU256Equal:
-      return "logic_as_u256_equal";
-    case OperatorType.TypeLogicAsU256Greater:
-      return "logic_as_u256_greater";
-    case OperatorType.TypeLogicAsU256Lesser:
-      return "logic_as_u256_lesser";
-    case OperatorType.TypeStringContains:
-      return "logic_string_contains";
-    case OperatorType.TypeStringNocaseContains:
-      return "logic_string_nocase_contains";
-    case OperatorType.TypeStringNocaseEqual:
-      return "logic_string_nocase_equal";
-    case OperatorType.TypeNumberAdd:
-      return "calc_number_add";
-    case OperatorType.TypeNumberSubtract:
-      return "calc_number_subtract";
-    case OperatorType.TypeNumberMultiply:
-      return "calc_number_multiply";
-    case OperatorType.TypeNumberDivide:
-      return "calc_number_divide";
-    case OperatorType.TypeNumberMod:
-      return "calc_number_mod";
-    case OperatorType.TypeLogicNot:
-      return "logic_not";
-    case OperatorType.TypeStringLength:
-      return "calc_string_length";
-    case OperatorType.TypeNumberAddress:
-      return "convert_number_address";
-    case OperatorType.TypeAddressNumber:
-      return "convert_address_number";
-    case OperatorType.TypeNumberString:
-      return "convert_number_string";
-    case OperatorType.TypeStringNumber:
-      return "convert_string_number";
-    case OperatorType.TypeSafeU8:
-      return "convert_safe_u8";
-    case OperatorType.TypeSafeU16:
-      return "convert_safe_u16";
-    case OperatorType.TypeSafeU32:
-      return "convert_safe_u32";
-    case OperatorType.TypeSafeU64:
-      return "convert_safe_u64";
-    case OperatorType.TypeSafeU128:
-      return "convert_safe_u128";
-    case OperatorType.TypeSafeU256:
-      return "convert_safe_u256";
-    case OperatorType.TypedValueType:
-      return "value_type";
-    case OperatorType.TypedValueVecLength:
-      return "vec_length";
-    case OperatorType.TypeStringIndexof:
-      return "calc_string_indexof";
-    case OperatorType.TypeStringNocaseIndexof:
-      return "calc_string_nocase_indexof";
-    case OperatorType.TypedValueVecIndexOf_Bool:
-      return "vec_indexof_bool";
-    case OperatorType.TypedValueVecIndexOf_Address:
-      return "vec_indexof_address";
-    case OperatorType.TypedValueVecIndexOf_String:
-      return "vec_indexof_string";
-    case OperatorType.TypedValueVecIndexOf_StringNoCase:
-      return "vec_indexof_string_nocase";
-    case OperatorType.TypedValueVecIndexOf_Number:
-      return "vec_indexof_number";
-    default:
-      return "unknown";
-  }
-};
-export {
-  checkType,
-  getCallEnvAccount,
-  resolveCallEnv,
-  restoreNodeFromOutput
 };
+//# sourceMappingURL=util.js.map