wowok 1.8.2 → 2.1.9

package/dist/esm/w/call/util.d.ts

@@ -0,0 +1,12 @@
+import type { CallEnv } from "../common.js";
+import { ValueType } from "../common.js";
+import { ContextType } from "../common.js";
+import type { GuardNode, GuardTableItem } from "./guard.js";
+export declare const getCallEnvAccount: (env: CallEnv) => Promise<string>;
+export declare const resolveCallEnv: (env: CallEnv) => Promise<string>;
+export declare const checkType: (type: ValueType | ContextType.TypeClock | ContextType.TypeGuard | ContextType.TypeSigner, type_required: ValueType | "number" | "variable" | "vec_number" | "vec", node?: GuardNode) => void;
+export interface RestoreNodeResult {
+    root: GuardNode;
+    rep_quote: Map<string, string[]>;
+}
+export declare const restoreNodeFromOutput: (output: Uint8Array, table: GuardTableItem[]) => RestoreNodeResult;

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

@@ -0,0 +1,646 @@
+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";
+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 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}`
+      );
+    }
+  }
+  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;
+};
+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 === 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 === "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)}`
+    );
+  }
+};
+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}`);
+  }
+};
+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;
+};
+const parseSingleOperandNode = (parserState, nodeProperty) => {
+  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;
+};
+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"
+      );
+    }
+    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;
+    };
+    while (position < output.length) {
+      const opCode = readByte();
+      switch (opCode) {
+        case ContextType.TypeConstant: {
+          const identifier = readByte();
+          nodeStack.push({ type: "identifier", identifier });
+          break;
+        }
+        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}`
+              );
+            }
+            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);
+                }
+              } 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 = [];
+          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;
+        }
+        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`
+            );
+          }
+          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}`
+          );
+      }
+    }
+    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}`
+    );
+  }
+};
+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
+};