wowok 2.1.13 → 2.1.16

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

@@ -1,129 +1,123 @@
-"use strict";
 // 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, index_js_2.GetAccountOrMark_Address)({
+import { bcs } from "../../bcs/index.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";
+export const getCallEnvAccount = async (env) => {
+    const acc = await 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`);
+        W_ERROR(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 resolveCallEnv = async (env) => {
-    env.network = await index_js_2.Config.Instance().network_get(env?.network);
-    const acc = await (0, exports.getCallEnvAccount)(env);
+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 local_js_1.LocalMark.Instance().get_many_address_availables(env.permission_guard);
+        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));
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `permission_guard not found: ${notFoundGuards.join(", ")}`);
+            W_ERROR(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.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 (0, index_js_2.GetAccountOrMark_Address)({
+        const r = await 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`);
+            W_ERROR(WErrors.InvalidParam, `referrer ${env.referrer} not found`);
         }
     }
     return acc;
 };
-exports.resolveCallEnv = resolveCallEnv;
 // ================================================
 // 从output和table恢复GuardNode的函数
 // ================================================
-const checkType = (type, type_required, node) => {
+export const checkType = (type, type_required, node) => {
     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) {
+        if (isValueTypeNumber(type) ||
+            type === ContextType.TypeClock ||
+            type === 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) {
+    else if (type_required === ValueType.Address) {
+        if (type === ContextType.TypeSigner ||
+            type === ContextType.TypeGuard ||
+            type === ValueType.Value) {
             return;
         }
     }
-    else if (type === common_js_1.ValueType.Value) {
+    else if (type === ValueType.Value) {
         // Value 是动态类型，可以匹配任何具体类型
         return;
     }
-    else if (type_required === common_js_1.ValueType.Value) {
+    else if (type_required === ValueType.Value) {
         // 任何类型都可以赋值给 Value 类型
         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) {
+        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 === 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) {
+        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) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `checkType: ${type} require type: ${type_required} with node: ${JSON.stringify(node)}`);
+        W_ERROR(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, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseNode: Unexpected end of output while parsing node");
+        W_ERROR(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
+        case 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");
+                W_ERROR(WErrors.InvalidParam, "parseNode: Missing identifier after TypeConstant opcode");
             }
             const identifierByte = parserState.output[parserState.currentPosition];
             parserState.currentPosition++;
@@ -138,103 +132,103 @@ const parseNode = (parserState) => {
                 );
             }*/
             return { type: "identifier", identifier: identifierByte };
-        case common_js_1.OperatorType.TypeQuery: // QUERY TYPE
+        case OperatorType.TypeQuery: // QUERY TYPE
             return parseQueryNode(parserState);
-        case common_js_1.OperatorType.TypeLogicAsU256GreaterEqual:
+        case OperatorType.TypeLogicAsU256GreaterEqual:
             return parseMultiOperandNode(parserState, "logic_as_u256_greater_or_equal");
-        case common_js_1.OperatorType.TypeLogicAsU256LesserEqual:
+        case OperatorType.TypeLogicAsU256LesserEqual:
             return parseMultiOperandNode(parserState, "logic_as_u256_lesser_or_equal");
-        case common_js_1.OperatorType.TypeLogicAsU256Equal:
+        case OperatorType.TypeLogicAsU256Equal:
             return parseMultiOperandNode(parserState, "logic_as_u256_equal");
-        case common_js_1.OperatorType.TypeLogicAsU256Greater:
+        case OperatorType.TypeLogicAsU256Greater:
             return parseMultiOperandNode(parserState, "logic_as_u256_greater");
-        case common_js_1.OperatorType.TypeLogicAsU256Lesser:
+        case OperatorType.TypeLogicAsU256Lesser:
             return parseMultiOperandNode(parserState, "logic_as_u256_lesser");
-        case common_js_1.OperatorType.TypeLogicEqual:
+        case OperatorType.TypeLogicEqual:
             return parseMultiOperandNode(parserState, "logic_equal");
-        case common_js_1.OperatorType.TypeLogicAnd:
+        case OperatorType.TypeLogicAnd:
             return parseMultiOperandNode(parserState, "logic_and");
-        case common_js_1.OperatorType.TypeLogicOr:
+        case OperatorType.TypeLogicOr:
             return parseMultiOperandNode(parserState, "logic_or");
-        case common_js_1.OperatorType.TypeStringContains:
+        case OperatorType.TypeStringContains:
             return parseMultiOperandNode(parserState, "logic_string_contains");
-        case common_js_1.OperatorType.TypeStringNocaseContains:
+        case OperatorType.TypeStringNocaseContains:
             return parseMultiOperandNode(parserState, "logic_string_nocase_contains");
-        case common_js_1.OperatorType.TypeStringNocaseEqual:
+        case OperatorType.TypeStringNocaseEqual:
             return parseMultiOperandNode(parserState, "logic_string_nocase_equal");
-        case common_js_1.OperatorType.TypeNumberAdd:
+        case OperatorType.TypeNumberAdd:
             return parseMultiOperandNode(parserState, "calc_number_add");
-        case common_js_1.OperatorType.TypeNumberSubtract:
+        case OperatorType.TypeNumberSubtract:
             return parseMultiOperandNode(parserState, "calc_number_subtract");
-        case common_js_1.OperatorType.TypeNumberMultiply:
+        case OperatorType.TypeNumberMultiply:
             return parseMultiOperandNode(parserState, "calc_number_multiply");
-        case common_js_1.OperatorType.TypeNumberDivide:
+        case OperatorType.TypeNumberDivide:
             return parseMultiOperandNode(parserState, "calc_number_divide");
-        case common_js_1.OperatorType.TypeNumberMod:
+        case OperatorType.TypeNumberMod:
             return parseMultiOperandNode(parserState, "calc_number_mod");
-        case common_js_1.OperatorType.TypeLogicNot:
+        case OperatorType.TypeLogicNot:
             return parseSingleOperandNode(parserState, "logic_not");
-        case common_js_1.OperatorType.TypeStringLength:
+        case OperatorType.TypeStringLength:
             return parseSingleOperandNode(parserState, "calc_string_length");
-        case common_js_1.OperatorType.TypeNumberAddress:
+        case OperatorType.TypeNumberAddress:
             return parseSingleOperandNode(parserState, "convert_number_address");
-        case common_js_1.OperatorType.TypeAddressNumber:
+        case OperatorType.TypeAddressNumber:
             return parseSingleOperandNode(parserState, "convert_address_number");
-        case common_js_1.OperatorType.TypeNumberString:
+        case OperatorType.TypeNumberString:
             return parseSingleOperandNode(parserState, "convert_number_string");
-        case common_js_1.OperatorType.TypeStringNumber:
+        case OperatorType.TypeStringNumber:
             return parseSingleOperandNode(parserState, "convert_string_number");
         /*case OperatorType.TypeStringLowercase:
             return parseSingleOperandNode(
                 parserState,
                 "convert_string_lowercase",
             );*/
-        case common_js_1.OperatorType.TypeSafeU8:
+        case OperatorType.TypeSafeU8:
             return parseSingleOperandNode(parserState, "convert_safe_u8");
-        case common_js_1.OperatorType.TypeSafeU16:
+        case OperatorType.TypeSafeU16:
             return parseSingleOperandNode(parserState, "convert_safe_u16");
-        case common_js_1.OperatorType.TypeSafeU32:
+        case OperatorType.TypeSafeU32:
             return parseSingleOperandNode(parserState, "convert_safe_u32");
-        case common_js_1.OperatorType.TypeSafeU64:
+        case OperatorType.TypeSafeU64:
             return parseSingleOperandNode(parserState, "convert_safe_u64");
-        case common_js_1.OperatorType.TypeSafeU128:
+        case OperatorType.TypeSafeU128:
             return parseSingleOperandNode(parserState, "convert_safe_u128");
-        case common_js_1.OperatorType.TypeSafeU256:
+        case OperatorType.TypeSafeU256:
             return parseSingleOperandNode(parserState, "convert_safe_u256");
-        case common_js_1.OperatorType.TypeStringIndexof:
+        case OperatorType.TypeStringIndexof:
             return parseTwoOperandNode(parserState, "calc_string_indexof");
-        case common_js_1.OperatorType.TypeStringNocaseIndexof:
+        case OperatorType.TypeStringNocaseIndexof:
             return parseTwoOperandNode(parserState, "calc_string_nocase_indexof");
         // typedValue 操作
-        case common_js_1.OperatorType.TypedValueType:
+        case OperatorType.TypedValueType:
             return parseSingleOperandNode(parserState, "value_type");
-        case common_js_1.OperatorType.TypedValueVecLength:
+        case OperatorType.TypedValueVecLength:
             return parseSingleOperandNode(parserState, "vec_length");
-        case common_js_1.OperatorType.TypedValueVecContains_Bool:
+        case OperatorType.TypedValueVecContains_Bool:
             return parseMultiOperandNode(parserState, "vec_contains_bool");
-        case common_js_1.OperatorType.TypedValueVecContains_Address:
+        case OperatorType.TypedValueVecContains_Address:
             return parseMultiOperandNode(parserState, "vec_contains_address");
-        case common_js_1.OperatorType.TypedValueVecContains_String:
+        case OperatorType.TypedValueVecContains_String:
             return parseMultiOperandNode(parserState, "vec_contains_string");
-        case common_js_1.OperatorType.TypedValueVecContains_StringNoCase:
+        case OperatorType.TypedValueVecContains_StringNoCase:
             return parseMultiOperandNode(parserState, "vec_contains_string_nocase");
-        case common_js_1.OperatorType.TypedValueVecContains_Number:
+        case OperatorType.TypedValueVecContains_Number:
             return parseMultiOperandNode(parserState, "vec_contains_number");
-        case common_js_1.OperatorType.TypedValueVecIndexOf_Bool:
+        case OperatorType.TypedValueVecIndexOf_Bool:
             return parseTwoOperandNode(parserState, "vec_indexof_bool");
-        case common_js_1.OperatorType.TypedValueVecIndexOf_Address:
+        case OperatorType.TypedValueVecIndexOf_Address:
             return parseTwoOperandNode(parserState, "vec_indexof_address");
-        case common_js_1.OperatorType.TypedValueVecIndexOf_String:
+        case OperatorType.TypedValueVecIndexOf_String:
             return parseTwoOperandNode(parserState, "vec_indexof_string");
-        case common_js_1.OperatorType.TypedValueVecIndexOf_StringNoCase:
+        case OperatorType.TypedValueVecIndexOf_StringNoCase:
             return parseTwoOperandNode(parserState, "vec_indexof_string_nocase");
-        case common_js_1.OperatorType.TypedValueVecIndexOf_Number:
+        case OperatorType.TypedValueVecIndexOf_Number:
             return parseTwoOperandNode(parserState, "vec_indexof_number");
-        case common_js_2.ContextType.TypeSigner:
+        case ContextType.TypeSigner:
             return { type: "context", context: "Signer" };
-        case common_js_2.ContextType.TypeGuard:
+        case ContextType.TypeGuard:
             return { type: "context", context: "Guard" };
-        case common_js_2.ContextType.TypeClock:
+        case ContextType.TypeClock:
             return { type: "context", context: "Clock" };
         default:
             throw new Error(`ParseGuardNode: Unknown opcode: ${opCode}`);
@@ -243,7 +237,7 @@ const parseNode = (parserState) => {
 const parseMultiOperandNode = (parserState, nodeProperty) => {
     // 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");
+        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];
@@ -267,7 +261,7 @@ const parseSingleOperandNode = (parserState, nodeProperty) => {
 const parseTwoOperandNode = (parserState, nodeProperty) => {
     // 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");
+        W_ERROR(WErrors.InvalidParam, "parseTwoOperandNode: Missing order byte");
     }
     const orderByte = parserState.output[parserState.currentPosition];
     parserState.currentPosition++;
@@ -287,33 +281,33 @@ const parseTwoOperandNode = (parserState, nodeProperty) => {
 const parseQueryNode = (parserState) => {
     // 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");
+        W_ERROR(WErrors.InvalidParam, "parseQueryNode: Missing witness byte after TypeQuery opcode");
     }
     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");
+        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) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "parseQueryNode: Not enough bytes for query ID after object identifier");
+        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 = index_js_1.bcs.U16.parse(remainingBytes);
+    const queryId = bcs.U16.parse(remainingBytes);
     parserState.currentPosition += 2;
     // Find the query definition
-    const query = guard_ins_js_1.GUARDQUERY.find((q) => q.id === queryId);
+    const query = 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`);
+        W_ERROR(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);
+    const queryInfo = getGuardQueryInfo(queryId);
     if (!queryInfo) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `parseQueryNode: Query name not found for ID ${queryId}`);
+        W_ERROR(WErrors.InvalidParam, `parseQueryNode: Query name not found for ID ${queryId}`);
     }
     // Parse parameters in reverse order (as serialized by buildNode)
     const parameters = [];
@@ -326,7 +320,7 @@ const parseQueryNode = (parserState) => {
         query: queryInfo.name,
         object: {
             identifier: objectIdentifier,
-            ...(witnessByte !== common_js_2.ContextType.TypeConstant
+            ...(witnessByte !== ContextType.TypeConstant
                 ? { convert_witness: witnessByte }
                 : {}),
         },
@@ -336,11 +330,11 @@ const parseQueryNode = (parserState) => {
 };
 // Main function to restore GuardNode from output and table
 // Uses a stack-based approach similar to the Rust implementation
-const restoreNodeFromOutput = (output, table) => {
+export 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");
+            W_ERROR(WErrors.InvalidParam, "restoreNodeFromOutput: output is empty");
         }
         // Use a stack to build the node tree, similar to Rust implementation
         const nodeStack = [];
@@ -349,14 +343,14 @@ const restoreNodeFromOutput = (output, table) => {
         // 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");
+                W_ERROR(WErrors.InvalidParam, "readByte: Unexpected end of output");
             }
             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");
+                W_ERROR(WErrors.InvalidParam, "readU16: Insufficient bytes for u16");
             }
             const value = output[position] + output[position + 1] * 256;
             position += 2;
@@ -366,35 +360,35 @@ const restoreNodeFromOutput = (output, table) => {
         while (position < output.length) {
             const opCode = readByte();
             switch (opCode) {
-                case common_js_2.ContextType.TypeConstant: {
+                case ContextType.TypeConstant: {
                     // TYPE_CONSTANT (48)
                     const identifier = readByte();
                     nodeStack.push({ type: "identifier", identifier });
                     break;
                 }
-                case common_js_2.ContextType.TypeSigner: // TYPE_SIGNER (45)
+                case ContextType.TypeSigner: // TYPE_SIGNER (45)
                     nodeStack.push({ type: "context", context: "Signer" });
                     break;
-                case common_js_2.ContextType.TypeClock:
+                case ContextType.TypeClock:
                     nodeStack.push({ type: "context", context: "Clock" });
                     break;
-                case common_js_2.ContextType.TypeGuard:
+                case ContextType.TypeGuard:
                     nodeStack.push({ type: "context", context: "Guard" });
                     break;
-                case common_js_1.OperatorType.TypeQuery: {
+                case OperatorType.TypeQuery: {
                     // TYPE_QUERY (40)
                     const witnessByte = readByte();
                     const identifier = readByte();
                     const queryId = readU16();
-                    const queryInfo = (0, guard_ins_js_1.getGuardQueryInfo)(queryId);
+                    const queryInfo = getGuardQueryInfo(queryId);
                     if (!queryInfo) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Query with ID ${queryId} not found`);
+                        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) {
-                            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient parameters for query ${queryInfo.name}`);
+                            W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient parameters for query ${queryInfo.name}`);
                         }
                         parameters.unshift(nodeStack.pop());
                     }
@@ -407,15 +401,15 @@ const restoreNodeFromOutput = (output, table) => {
                             parameters[0].identifier &&
                             !item.b_submission);
                         const repItemValueType = rep_item
-                            ? (0, common_js_1.parseValueType)(rep_item.value_type)
+                            ? parseValueType(rep_item.value_type)
                             : undefined;
                         const policyItemValueType = policy_item
-                            ? (0, common_js_1.parseValueType)(policy_item.value_type)
+                            ? parseValueType(policy_item.value_type)
                             : undefined;
                         if (rep_item &&
                             policy_item &&
-                            repItemValueType === common_js_1.ValueType.Address &&
-                            policyItemValueType === common_js_1.ValueType.String) {
+                            repItemValueType === ValueType.Address &&
+                            policyItemValueType === ValueType.String) {
                             if (rep_quote.has(rep_item.value)) {
                                 if (!rep_quote
                                     .get(rep_item.value)
@@ -437,7 +431,7 @@ const restoreNodeFromOutput = (output, table) => {
                         query: queryInfo.name,
                         object: {
                             identifier,
-                            ...(witnessByte !== common_js_2.ContextType.TypeConstant
+                            ...(witnessByte !== ContextType.TypeConstant
                                 ? { convert_witness: witnessByte }
                                 : {}),
                         },
@@ -445,22 +439,22 @@ const restoreNodeFromOutput = (output, table) => {
                     });
                     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: {
+                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
@@ -468,7 +462,7 @@ const restoreNodeFromOutput = (output, table) => {
                     // 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`);
+                            W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operands for multi-operand operation`);
                         }
                         operands.push(nodeStack.pop());
                     }
@@ -479,22 +473,22 @@ const restoreNodeFromOutput = (output, table) => {
                     });
                     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: {
+                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) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operand for single-operand operation`);
+                        W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operand for single-operand operation`);
                     }
                     const operand = nodeStack.pop();
                     const nodeProperty = getNodePropertyFromOpCode(opCode);
@@ -504,17 +498,17 @@ const restoreNodeFromOutput = (output, table) => {
                     });
                     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: {
+                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) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operands for two-operand operation`);
+                        W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Insufficient operands for two-operand operation`);
                     }
                     // Pop in reverse order of serialization
                     const nodeLeft = nodeStack.pop();
@@ -529,12 +523,12 @@ const restoreNodeFromOutput = (output, table) => {
                     break;
                 }
                 default:
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `restoreNodeFromOutput: Unknown opcode ${opCode}`);
+                    W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Unknown opcode ${opCode}`);
             }
         }
         // 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}`);
+            W_ERROR(WErrors.InvalidParam, `restoreNodeFromOutput: Expected 1 node in stack, found ${nodeStack.length}`);
         }
         return {
             root: nodeStack[0],
@@ -545,83 +539,82 @@ const restoreNodeFromOutput = (output, table) => {
         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 common_js_1.OperatorType.TypeLogicEqual:
+        case OperatorType.TypeLogicEqual:
             return "logic_equal";
-        case common_js_1.OperatorType.TypeLogicAnd:
+        case OperatorType.TypeLogicAnd:
             return "logic_and";
-        case common_js_1.OperatorType.TypeLogicOr:
+        case OperatorType.TypeLogicOr:
             return "logic_or";
-        case common_js_1.OperatorType.TypeLogicAsU256GreaterEqual:
+        case OperatorType.TypeLogicAsU256GreaterEqual:
             return "logic_as_u256_greater_or_equal";
-        case common_js_1.OperatorType.TypeLogicAsU256LesserEqual:
+        case OperatorType.TypeLogicAsU256LesserEqual:
             return "logic_as_u256_lesser_or_equal";
-        case common_js_1.OperatorType.TypeLogicAsU256Equal:
+        case OperatorType.TypeLogicAsU256Equal:
             return "logic_as_u256_equal";
-        case common_js_1.OperatorType.TypeLogicAsU256Greater:
+        case OperatorType.TypeLogicAsU256Greater:
             return "logic_as_u256_greater";
-        case common_js_1.OperatorType.TypeLogicAsU256Lesser:
+        case OperatorType.TypeLogicAsU256Lesser:
             return "logic_as_u256_lesser";
-        case common_js_1.OperatorType.TypeStringContains:
+        case OperatorType.TypeStringContains:
             return "logic_string_contains";
-        case common_js_1.OperatorType.TypeStringNocaseContains:
+        case OperatorType.TypeStringNocaseContains:
             return "logic_string_nocase_contains";
-        case common_js_1.OperatorType.TypeStringNocaseEqual:
+        case OperatorType.TypeStringNocaseEqual:
             return "logic_string_nocase_equal";
-        case common_js_1.OperatorType.TypeNumberAdd:
+        case OperatorType.TypeNumberAdd:
             return "calc_number_add";
-        case common_js_1.OperatorType.TypeNumberSubtract:
+        case OperatorType.TypeNumberSubtract:
             return "calc_number_subtract";
-        case common_js_1.OperatorType.TypeNumberMultiply:
+        case OperatorType.TypeNumberMultiply:
             return "calc_number_multiply";
-        case common_js_1.OperatorType.TypeNumberDivide:
+        case OperatorType.TypeNumberDivide:
             return "calc_number_divide";
-        case common_js_1.OperatorType.TypeNumberMod:
+        case OperatorType.TypeNumberMod:
             return "calc_number_mod";
-        case common_js_1.OperatorType.TypeLogicNot:
+        case OperatorType.TypeLogicNot:
             return "logic_not";
-        case common_js_1.OperatorType.TypeStringLength:
+        case OperatorType.TypeStringLength:
             return "calc_string_length";
-        case common_js_1.OperatorType.TypeNumberAddress:
+        case OperatorType.TypeNumberAddress:
             return "convert_number_address";
-        case common_js_1.OperatorType.TypeAddressNumber:
+        case OperatorType.TypeAddressNumber:
             return "convert_address_number";
-        case common_js_1.OperatorType.TypeNumberString:
+        case OperatorType.TypeNumberString:
             return "convert_number_string";
-        case common_js_1.OperatorType.TypeStringNumber:
+        case OperatorType.TypeStringNumber:
             return "convert_string_number";
-        case common_js_1.OperatorType.TypeSafeU8:
+        case OperatorType.TypeSafeU8:
             return "convert_safe_u8";
-        case common_js_1.OperatorType.TypeSafeU16:
+        case OperatorType.TypeSafeU16:
             return "convert_safe_u16";
-        case common_js_1.OperatorType.TypeSafeU32:
+        case OperatorType.TypeSafeU32:
             return "convert_safe_u32";
-        case common_js_1.OperatorType.TypeSafeU64:
+        case OperatorType.TypeSafeU64:
             return "convert_safe_u64";
-        case common_js_1.OperatorType.TypeSafeU128:
+        case OperatorType.TypeSafeU128:
             return "convert_safe_u128";
-        case common_js_1.OperatorType.TypeSafeU256:
+        case OperatorType.TypeSafeU256:
             return "convert_safe_u256";
-        case common_js_1.OperatorType.TypedValueType:
+        case OperatorType.TypedValueType:
             return "value_type";
-        case common_js_1.OperatorType.TypedValueVecLength:
+        case OperatorType.TypedValueVecLength:
             return "vec_length";
-        case common_js_1.OperatorType.TypeStringIndexof:
+        case OperatorType.TypeStringIndexof:
             return "calc_string_indexof";
-        case common_js_1.OperatorType.TypeStringNocaseIndexof:
+        case OperatorType.TypeStringNocaseIndexof:
             return "calc_string_nocase_indexof";
-        case common_js_1.OperatorType.TypedValueVecIndexOf_Bool:
+        case OperatorType.TypedValueVecIndexOf_Bool:
             return "vec_indexof_bool";
-        case common_js_1.OperatorType.TypedValueVecIndexOf_Address:
+        case OperatorType.TypedValueVecIndexOf_Address:
             return "vec_indexof_address";
-        case common_js_1.OperatorType.TypedValueVecIndexOf_String:
+        case OperatorType.TypedValueVecIndexOf_String:
             return "vec_indexof_string";
-        case common_js_1.OperatorType.TypedValueVecIndexOf_StringNoCase:
+        case OperatorType.TypedValueVecIndexOf_StringNoCase:
             return "vec_indexof_string_nocase";
-        case common_js_1.OperatorType.TypedValueVecIndexOf_Number:
+        case OperatorType.TypedValueVecIndexOf_Number:
             return "vec_indexof_number";
         default:
             return "unknown";