wowok 1.8.2 → 2.1.9

package/dist/cjs/w/common.js

@@ -0,0 +1,625 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var common_exports = {};
+__export(common_exports, {
+  CoinWrapPrefix: () => CoinWrapPrefix,
+  ContextType: () => ContextType,
+  ENTITY_LINKER_ADDRESS: () => ENTITY_LINKER_ADDRESS,
+  ENTITY_REGISTRAR_ADDRESS: () => ENTITY_REGISTRAR_ADDRESS,
+  EntityAddress: () => EntityAddress,
+  GasCoinType: () => GasCoinType,
+  GasTokenType: () => GasTokenType,
+  GetObject: () => GetObject,
+  GetObjectDescription: () => GetObjectDescription,
+  GetObjectExisted: () => GetObjectExisted,
+  IsBcsStringLength: () => IsBcsStringLength,
+  IsValidArgType: () => IsValidArgType,
+  IsValidBalance: () => IsValidBalance,
+  IsValidEndpoint: () => IsValidEndpoint,
+  MAX_DEPENDED_COUNT: () => MAX_DEPENDED_COUNT,
+  MAX_DESCRIPTION_LENGTH: () => MAX_DESCRIPTION_LENGTH,
+  MAX_ENV_PERMISSION_GUARD_COUNT: () => MAX_ENV_PERMISSION_GUARD_COUNT,
+  MAX_GUARD_TABLE_ITEM_LENGTH: () => MAX_GUARD_TABLE_ITEM_LENGTH,
+  MAX_INPUT_SIZE: () => MAX_INPUT_SIZE,
+  MAX_LONG_NAME_LENGTH: () => MAX_LONG_NAME_LENGTH,
+  MAX_MULTI_OPERANDS: () => MAX_MULTI_OPERANDS,
+  MAX_NAME_LENGTH: () => MAX_NAME_LENGTH,
+  MAX_PERMISSION_GUARD_COUNT: () => MAX_PERMISSION_GUARD_COUNT,
+  MAX_TABLE_SIZE: () => MAX_TABLE_SIZE,
+  Modules: () => Modules,
+  ObjectType: () => ObjectType,
+  OperatorType: () => OperatorType,
+  PackageAddress: () => PackageAddress,
+  RecipientType: () => RecipientType,
+  RegistrarAddress: () => RegistrarAddress,
+  ValueType: () => ValueType,
+  WitnessType: () => WitnessType,
+  arbitrationFn: () => arbitrationFn,
+  contactFn: () => contactFn,
+  createValueContainer: () => createValueContainer,
+  demandFn: () => demandFn,
+  isGasTokenType: () => isGasTokenType,
+  isThisPackage: () => isThisPackage,
+  isValidArray: () => isValidArray,
+  isValidDescription: () => isValidDescription,
+  isValidHttpUrl: () => isValidHttpUrl,
+  isValidLongName: () => isValidLongName,
+  isValidName: () => isValidName,
+  isValidU128: () => isValidU128,
+  isValidU16: () => isValidU16,
+  isValidU256: () => isValidU256,
+  isValidU32: () => isValidU32,
+  isValidU64: () => isValidU64,
+  isValidU8: () => isValidU8,
+  isValidValueType: () => isValidValueType,
+  isValidValueTypeInput: () => isValidValueTypeInput,
+  isValueTypeNumber: () => isValueTypeNumber,
+  isWitnessType: () => isWitnessType,
+  machineFn: () => machineFn,
+  object_name_from_type: () => object_name_from_type,
+  parseValueType: () => parseValueType,
+  repositoryFn: () => repositoryFn,
+  rewardFn: () => rewardFn,
+  serviceFn: () => serviceFn,
+  toTxAddress: () => toTxAddress,
+  toTxAddressVec: () => toTxAddressVec,
+  toTxObject: () => toTxObject,
+  toTxString: () => toTxString,
+  toTxU128: () => toTxU128,
+  toTxU16: () => toTxU16,
+  toTxU16Vec: () => toTxU16Vec,
+  toTxU256: () => toTxU256,
+  toTxU32: () => toTxU32,
+  toTxU64: () => toTxU64,
+  toTxU8: () => toTxU8,
+  treasuryFn: () => treasuryFn,
+  valueTypeToString: () => valueTypeToString
+});
+module.exports = __toCommonJS(common_exports);
+var import_bcs = require("../bcs/index.js");
+var import_exception = require("./exception.js");
+var import_local = require("./local/local.js");
+var ValueType = /* @__PURE__ */ ((ValueType2) => {
+  ValueType2[ValueType2["Bool"] = 0] = "Bool";
+  ValueType2[ValueType2["Address"] = 1] = "Address";
+  ValueType2[ValueType2["String"] = 2] = "String";
+  ValueType2[ValueType2["U8"] = 3] = "U8";
+  ValueType2[ValueType2["U16"] = 4] = "U16";
+  ValueType2[ValueType2["U32"] = 5] = "U32";
+  ValueType2[ValueType2["U64"] = 6] = "U64";
+  ValueType2[ValueType2["U128"] = 7] = "U128";
+  ValueType2[ValueType2["U256"] = 8] = "U256";
+  ValueType2[ValueType2["VecBool"] = 9] = "VecBool";
+  ValueType2[ValueType2["VecAddress"] = 10] = "VecAddress";
+  ValueType2[ValueType2["VecString"] = 11] = "VecString";
+  ValueType2[ValueType2["VecU8"] = 12] = "VecU8";
+  ValueType2[ValueType2["VecU16"] = 13] = "VecU16";
+  ValueType2[ValueType2["VecU32"] = 14] = "VecU32";
+  ValueType2[ValueType2["VecU64"] = 15] = "VecU64";
+  ValueType2[ValueType2["VecU128"] = 16] = "VecU128";
+  ValueType2[ValueType2["VecU256"] = 17] = "VecU256";
+  ValueType2[ValueType2["VecVecU8"] = 18] = "VecVecU8";
+  ValueType2[ValueType2["Value"] = 19] = "Value";
+  return ValueType2;
+})(ValueType || {});
+const createValueContainer = (valueType, value) => {
+  return {
+    valueType,
+    value
+  };
+};
+const parseValueType = (input) => {
+  if (typeof input === "number") {
+    if (input >= 0 && input <= 19) return input;
+    throw new Error(
+      `Invalid ValueType number: ${input}. Valid range: 0-19`
+    );
+  }
+  const validNames = Object.keys(ValueType).filter((k) => isNaN(Number(k)));
+  const lowerInput = input.toLowerCase();
+  const enumValue = validNames.find(
+    (name) => name.toLowerCase() === lowerInput
+  );
+  if (enumValue === void 0) {
+    throw new Error(
+      `Invalid ValueType string: "${input}". Valid values: ${validNames.join(", ")}`
+    );
+  }
+  return ValueType[enumValue];
+};
+const valueTypeToString = (type) => {
+  return ValueType[type];
+};
+const isValidValueTypeInput = (input) => {
+  if (typeof input === "number") {
+    return input >= 0 && input <= 19;
+  }
+  if (typeof input === "string") {
+    const upperKey = input.toUpperCase();
+    const enumValue = ValueType[upperKey];
+    return typeof enumValue === "number";
+  }
+  return false;
+};
+var OperatorType = /* @__PURE__ */ ((OperatorType2) => {
+  OperatorType2[OperatorType2["TypeQuery"] = 40] = "TypeQuery";
+  OperatorType2[OperatorType2["TypeNumberAdd"] = 200] = "TypeNumberAdd";
+  OperatorType2[OperatorType2["TypeNumberSubtract"] = 201] = "TypeNumberSubtract";
+  OperatorType2[OperatorType2["TypeNumberMultiply"] = 202] = "TypeNumberMultiply";
+  OperatorType2[OperatorType2["TypeNumberDivide"] = 203] = "TypeNumberDivide";
+  OperatorType2[OperatorType2["TypeNumberMod"] = 204] = "TypeNumberMod";
+  OperatorType2[OperatorType2["TypeNumberAddress"] = 205] = "TypeNumberAddress";
+  OperatorType2[OperatorType2["TypeNumberString"] = 206] = "TypeNumberString";
+  OperatorType2[OperatorType2["TypeAddressNumber"] = 207] = "TypeAddressNumber";
+  OperatorType2[OperatorType2["TypeStringNumber"] = 208] = "TypeStringNumber";
+  OperatorType2[OperatorType2["TypeSafeU8"] = 220] = "TypeSafeU8";
+  OperatorType2[OperatorType2["TypeSafeU16"] = 221] = "TypeSafeU16";
+  OperatorType2[OperatorType2["TypeSafeU32"] = 222] = "TypeSafeU32";
+  OperatorType2[OperatorType2["TypeSafeU64"] = 223] = "TypeSafeU64";
+  OperatorType2[OperatorType2["TypeSafeU128"] = 224] = "TypeSafeU128";
+  OperatorType2[OperatorType2["TypeSafeU256"] = 225] = "TypeSafeU256";
+  OperatorType2[OperatorType2["TypeStringLength"] = 61] = "TypeStringLength";
+  OperatorType2[OperatorType2["TypeStringIndexof"] = 62] = "TypeStringIndexof";
+  OperatorType2[OperatorType2["TypeStringNocaseIndexof"] = 63] = "TypeStringNocaseIndexof";
+  OperatorType2[OperatorType2["TypeStringContains"] = 64] = "TypeStringContains";
+  OperatorType2[OperatorType2["TypeStringNocaseContains"] = 65] = "TypeStringNocaseContains";
+  OperatorType2[OperatorType2["TypeStringNocaseEqual"] = 66] = "TypeStringNocaseEqual";
+  OperatorType2[OperatorType2["TypedValueType"] = 70] = "TypedValueType";
+  OperatorType2[OperatorType2["TypedValueVecLength"] = 71] = "TypedValueVecLength";
+  OperatorType2[OperatorType2["TypedValueVecContains_Bool"] = 72] = "TypedValueVecContains_Bool";
+  OperatorType2[OperatorType2["TypedValueVecContains_Address"] = 73] = "TypedValueVecContains_Address";
+  OperatorType2[OperatorType2["TypedValueVecContains_String"] = 74] = "TypedValueVecContains_String";
+  OperatorType2[OperatorType2["TypedValueVecContains_StringNoCase"] = 75] = "TypedValueVecContains_StringNoCase";
+  OperatorType2[OperatorType2["TypedValueVecContains_Number"] = 76] = "TypedValueVecContains_Number";
+  OperatorType2[OperatorType2["TypedValueVecContains_U8"] = 82] = "TypedValueVecContains_U8";
+  OperatorType2[OperatorType2["TypedValueVecContains_U16"] = 83] = "TypedValueVecContains_U16";
+  OperatorType2[OperatorType2["TypedValueVecContains_U32"] = 84] = "TypedValueVecContains_U32";
+  OperatorType2[OperatorType2["TypedValueVecContains_U64"] = 85] = "TypedValueVecContains_U64";
+  OperatorType2[OperatorType2["TypedValueVecContains_U128"] = 86] = "TypedValueVecContains_U128";
+  OperatorType2[OperatorType2["TypedValueVecContains_U256"] = 87] = "TypedValueVecContains_U256";
+  OperatorType2[OperatorType2["TypedValueVecIndexOf_Bool"] = 77] = "TypedValueVecIndexOf_Bool";
+  OperatorType2[OperatorType2["TypedValueVecIndexOf_Address"] = 78] = "TypedValueVecIndexOf_Address";
+  OperatorType2[OperatorType2["TypedValueVecIndexOf_String"] = 79] = "TypedValueVecIndexOf_String";
+  OperatorType2[OperatorType2["TypedValueVecIndexOf_StringNoCase"] = 80] = "TypedValueVecIndexOf_StringNoCase";
+  OperatorType2[OperatorType2["TypedValueVecIndexOf_Number"] = 81] = "TypedValueVecIndexOf_Number";
+  OperatorType2[OperatorType2["TypeLogicEqual"] = 90] = "TypeLogicEqual";
+  OperatorType2[OperatorType2["TypeLogicAsU256Greater"] = 91] = "TypeLogicAsU256Greater";
+  OperatorType2[OperatorType2["TypeLogicAsU256GreaterEqual"] = 92] = "TypeLogicAsU256GreaterEqual";
+  OperatorType2[OperatorType2["TypeLogicAsU256Lesser"] = 93] = "TypeLogicAsU256Lesser";
+  OperatorType2[OperatorType2["TypeLogicAsU256LesserEqual"] = 94] = "TypeLogicAsU256LesserEqual";
+  OperatorType2[OperatorType2["TypeLogicAsU256Equal"] = 95] = "TypeLogicAsU256Equal";
+  OperatorType2[OperatorType2["TypeLogicAnd"] = 96] = "TypeLogicAnd";
+  OperatorType2[OperatorType2["TypeLogicOr"] = 97] = "TypeLogicOr";
+  OperatorType2[OperatorType2["TypeLogicNot"] = 98] = "TypeLogicNot";
+  return OperatorType2;
+})(OperatorType || {});
+var WitnessType = /* @__PURE__ */ ((WitnessType2) => {
+  WitnessType2[WitnessType2["TypeOrderProgress"] = 100] = "TypeOrderProgress";
+  WitnessType2[WitnessType2["TypeOrderMachine"] = 101] = "TypeOrderMachine";
+  WitnessType2[WitnessType2["TypeOrderService"] = 102] = "TypeOrderService";
+  WitnessType2[WitnessType2["TypeProgressMachine"] = 103] = "TypeProgressMachine";
+  WitnessType2[WitnessType2["TypeArbOrder"] = 104] = "TypeArbOrder";
+  WitnessType2[WitnessType2["TypeArbArbitration"] = 105] = "TypeArbArbitration";
+  WitnessType2[WitnessType2["TypeArbProgress"] = 106] = "TypeArbProgress";
+  WitnessType2[WitnessType2["TypeArbMachine"] = 107] = "TypeArbMachine";
+  WitnessType2[WitnessType2["TypeArbService"] = 108] = "TypeArbService";
+  return WitnessType2;
+})(WitnessType || {});
+const isWitnessType = (type) => {
+  return type != null && type >= 100 /* TypeOrderProgress */ && type <= 108 /* TypeArbService */;
+};
+var ContextType = /* @__PURE__ */ ((ContextType2) => {
+  ContextType2[ContextType2["TypeSigner"] = 45] = "TypeSigner";
+  ContextType2[ContextType2["TypeClock"] = 46] = "TypeClock";
+  ContextType2[ContextType2["TypeGuard"] = 47] = "TypeGuard";
+  ContextType2[ContextType2["TypeConstant"] = 48] = "TypeConstant";
+  return ContextType2;
+})(ContextType || {});
+var Modules = /* @__PURE__ */ ((Modules2) => {
+  Modules2["Machine"] = "machine";
+  Modules2["Progress"] = "progress";
+  Modules2["Repository"] = "repository";
+  Modules2["Permission"] = "permission";
+  Modules2["Passport"] = "passport";
+  Modules2["Guard"] = "guard";
+  Modules2["Demand"] = "demand";
+  Modules2["Order"] = "order";
+  Modules2["Service"] = "service";
+  Modules2["Resource"] = "resource";
+  Modules2["Entity"] = "entity";
+  Modules2["Wowok"] = "wowok";
+  Modules2["Treasury"] = "treasury";
+  Modules2["Payment"] = "payment";
+  Modules2["Arbitration"] = "arbitration";
+  Modules2["Arb"] = "arb";
+  Modules2["Allocation"] = "allocation";
+  return Modules2;
+})(Modules || {});
+const PackageAddress = "0x2";
+const GasTokenType = "0x2::wow::WOW";
+const GasCoinType = "0x2::coin::Coin<0x2::wow::WOW>";
+const RegistrarAddress = "0xaaa";
+const EntityAddress = "0xaab";
+const MAX_ENV_PERMISSION_GUARD_COUNT = 4;
+const isGasTokenType = (token_type) => {
+  return token_type === GasTokenType;
+};
+const isValidValueType = (valueType) => {
+  return valueType >= 0 /* Bool */ && valueType <= 19 /* Value */;
+};
+const isThisPackage = (type) => {
+  return type.startsWith("0x2::");
+};
+const isValidArray = (arr, validator) => {
+  if (!Array.isArray(arr)) return false;
+  return arr.every((item) => validator(item));
+};
+const isValidU8 = (value) => {
+  if (typeof value === "string") {
+    const num = parseInt(value, 10);
+    return !isNaN(num) && Number.isInteger(num) && num >= 0 && num <= 255;
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= 255n;
+  }
+  return Number.isInteger(value) && value >= 0 && value <= 255;
+};
+const isValidU16 = (value) => {
+  if (typeof value === "string") {
+    const num = parseInt(value, 10);
+    return !isNaN(num) && Number.isInteger(num) && num >= 0 && num <= 65535;
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= 65535n;
+  }
+  return Number.isInteger(value) && value >= 0 && value <= 65535;
+};
+const isValidU64 = (value) => {
+  if (typeof value === "string") {
+    if (value.length > 15) {
+      try {
+        const bigNum = BigInt(value);
+        return bigNum >= 0n && bigNum <= 18446744073709551615n;
+      } catch {
+        return false;
+      }
+    } else {
+      const num = parseInt(value, 10);
+      return !isNaN(num) && Number.isInteger(num) && num >= 0 && num <= Number.MAX_SAFE_INTEGER;
+    }
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= 18446744073709551615n;
+  }
+  return Number.isInteger(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+};
+const isValidU128 = (value) => {
+  if (typeof value === "string") {
+    try {
+      const bigNum = BigInt(value);
+      return bigNum >= 0n && bigNum <= 340282366920938463463374607431768211455n;
+    } catch {
+      return false;
+    }
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= 340282366920938463463374607431768211455n;
+  }
+  return Number.isInteger(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+};
+const isValidU256 = (value) => {
+  if (typeof value === "string") {
+    try {
+      const bigNum = BigInt(value);
+      return bigNum >= 0n && bigNum <= 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+    } catch {
+      return false;
+    }
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
+  }
+  return Number.isInteger(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER;
+};
+const isValidU32 = (value) => {
+  if (typeof value === "string") {
+    const num = parseInt(value, 10);
+    return !isNaN(num) && Number.isInteger(num) && num >= 0 && num <= 4294967295;
+  }
+  if (typeof value === "bigint") {
+    return value >= 0n && value <= 4294967295n;
+  }
+  return Number.isInteger(value) && value >= 0 && value <= 4294967295;
+};
+const IsBcsStringLength = (str, max_len) => {
+  return import_bcs.bcs.string().serialize(str).toBytes().length <= max_len;
+};
+const MAX_DESCRIPTION_LENGTH = 4e3;
+const MAX_NAME_LENGTH = 64;
+const MAX_LONG_NAME_LENGTH = 256;
+const MAX_GUARD_TABLE_ITEM_LENGTH = 256;
+const MAX_INPUT_SIZE = 1024;
+const MAX_TABLE_SIZE = 4e4;
+const MAX_DEPENDED_COUNT = 4;
+const MAX_MULTI_OPERANDS = 8;
+const isValidDescription = (description) => {
+  return IsBcsStringLength(description, MAX_DESCRIPTION_LENGTH);
+};
+const isValidName = (name) => {
+  return IsBcsStringLength(name, MAX_NAME_LENGTH) && !name.toLowerCase().startsWith("0x");
+};
+const isValidLongName = (name) => {
+  return IsBcsStringLength(name, MAX_LONG_NAME_LENGTH);
+};
+const isValidHttpUrl = (url) => {
+  try {
+    const newUrl = new URL(url);
+    return newUrl.protocol === "http:" || newUrl.protocol === "https:" || newUrl.protocol === "ipfs:";
+  } catch (_) {
+    return false;
+  }
+};
+const isValueTypeNumber = (valueType) => {
+  return valueType === 3 /* U8 */ || valueType === 4 /* U16 */ || valueType === 5 /* U32 */ || valueType === 6 /* U64 */ || valueType === 7 /* U128 */ || valueType === 8 /* U256 */;
+};
+const toTxObject = (tx, arg) => {
+  if (typeof arg === "string") {
+    return tx.object(arg);
+  }
+  return arg;
+};
+const toTxString = (tx, arg) => {
+  if (arg === void 0 || arg === null) {
+    return tx.pure.string("");
+  }
+  if (typeof arg === "string") {
+    return tx.pure.string(arg);
+  }
+  return arg;
+};
+const toTxU8 = (tx, arg) => {
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "bigint") {
+    if (!isValidU8(arg)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU8, `Invalid U8 value: ${arg}`);
+    }
+    return tx.pure.u8(Number(arg));
+  }
+  return arg;
+};
+const toTxU16 = (tx, arg) => {
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "bigint") {
+    if (!isValidU16(arg)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU16, `Invalid U16 value: ${arg}`);
+    }
+    return tx.pure.u16(Number(arg));
+  }
+  return arg;
+};
+const toTxU32 = (tx, arg) => {
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "bigint") {
+    if (!isValidU32(arg)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU32, `Invalid U32 value: ${arg}`);
+    }
+    return tx.pure.u32(Number(arg));
+  }
+  return arg;
+};
+const toTxU128 = (tx, arg) => {
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "bigint") {
+    if (!isValidU128(arg)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU128, `Invalid U128 value: ${arg}`);
+    }
+    return tx.pure.u128(arg);
+  }
+  return arg;
+};
+const toTxU256 = (tx, arg) => {
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "bigint") {
+    if (!isValidU256(arg)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU256, `Invalid U256 value: ${arg}`);
+    }
+    return tx.pure.u256(arg);
+  }
+  return arg;
+};
+const toTxU64 = (tx, arg) => {
+  if (typeof arg === "string" || typeof arg === "number" || typeof arg === "bigint") {
+    if (!isValidU64(arg)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU64, `Invalid U64 value: ${arg}`);
+    }
+    return tx.pure.u64(arg);
+  }
+  return arg;
+};
+const toTxAddress = (tx, arg) => {
+  if (typeof arg === "string") {
+    return tx.pure.address(arg);
+  }
+  return arg;
+};
+const toTxAddressVec = (tx, arg, max_len) => {
+  if (Array.isArray(arg)) {
+    if (arg.length > max_len) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.AddressCountExceeded,
+        `Invalid AddressVec length: ${arg.length}`
+      );
+    }
+    return tx.pure.vector(
+      "address",
+      arg
+    );
+  }
+  return arg;
+};
+const toTxU16Vec = (tx, arg, max_len) => {
+  if (Array.isArray(arg)) {
+    if (arg.length > max_len) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.NumberCountExceeded,
+        `Invalid U16Vec length: ${arg.length}`
+      );
+    }
+    return tx.pure.vector(
+      "u16",
+      arg.map((e) => {
+        if (!isValidU16(e)) {
+          (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidU16, `Invalid U16 value: ${e}`);
+        }
+        return Number(e);
+      })
+    );
+  }
+  return arg;
+};
+const object_name_from_type = (type_repr) => {
+  if (!type_repr) return void 0;
+  let i = type_repr.indexOf("::");
+  if (i > 0 && type_repr.slice(0, i) === "0x2") {
+    i = type_repr.indexOf("<");
+    if (i > 0) {
+      type_repr = type_repr.slice(0, i);
+    }
+    const n = type_repr.lastIndexOf("::");
+    if (n > 0) {
+      return type_repr.slice(n + 2);
+    }
+  }
+  return void 0;
+};
+function isTypeNamedObjectWithPermission(obj) {
+  return obj != null && typeof obj === "object" && "type_parameter" in obj && typeof obj.type_parameter === "string";
+}
+function isNamedObjectWithPermission(obj) {
+  return obj != null && typeof obj === "object" && "permission" in obj;
+}
+function isNamedObject(obj) {
+  return obj != null && typeof obj === "object";
+}
+function isNamedObjectWithDescription(obj) {
+  return obj != null && typeof obj === "object" && "description" in obj;
+}
+function isTypeNamedObjectWithDescription(obj) {
+  return obj != null && typeof obj === "object" && "type_parameter" in obj && typeof obj.type_parameter === "string";
+}
+const GetObjectExisted = async (object) => {
+  if (typeof object === "string") {
+    return await import_local.LocalMark.Instance().get_address(object);
+  }
+  return void 0;
+};
+const GetObjectDescription = (object) => {
+  return isNamedObjectWithDescription(object) ? object.description : void 0;
+};
+const GetObject = (object) => {
+  if (isTypeNamedObjectWithPermission(object)) {
+    return object;
+  } else if (isTypeNamedObjectWithDescription(object)) {
+    return object;
+  } else if (isNamedObjectWithPermission(object)) {
+    return object;
+  } else if (isNamedObject(object)) {
+    return object;
+  }
+  return void 0;
+};
+const MAX_PERMISSION_GUARD_COUNT = 4;
+const CoinWrapPrefix = `${PackageAddress}::payment::CoinWrapper`;
+const IsValidBalance = (balance) => {
+  return isValidU64(balance);
+};
+const IsValidEndpoint = (endpoint) => {
+  return endpoint && IsBcsStringLength(endpoint, 1024);
+};
+const IsValidArgType = (arg_type) => {
+  if (arg_type) {
+    const arr = arg_type.split("::");
+    if (arr.length >= 3) {
+      return true;
+    }
+  }
+  return false;
+};
+var RecipientType = /* @__PURE__ */ ((RecipientType2) => {
+  RecipientType2[RecipientType2["GuardIdentifier"] = 0] = "GuardIdentifier";
+  RecipientType2[RecipientType2["Entity"] = 1] = "Entity";
+  RecipientType2[RecipientType2["Signer"] = 2] = "Signer";
+  return RecipientType2;
+})(RecipientType || {});
+function serviceFn(name) {
+  return `${PackageAddress}::service::${name}`;
+}
+function demandFn(name) {
+  return `${PackageAddress}::demand::${name}`;
+}
+function machineFn(name) {
+  return `${PackageAddress}::machine::${name}`;
+}
+function contactFn(name) {
+  return `${PackageAddress}::contact::${name}`;
+}
+function treasuryFn(name) {
+  return `${PackageAddress}::treasury::${name}`;
+}
+function arbitrationFn(name) {
+  return `${PackageAddress}::arbitration::${name}`;
+}
+function repositoryFn(name) {
+  return `${PackageAddress}::repository::${name}`;
+}
+function rewardFn(name) {
+  return `${PackageAddress}::reward::${name}`;
+}
+var ObjectType = /* @__PURE__ */ ((ObjectType2) => {
+  ObjectType2["Permission"] = "Permission";
+  ObjectType2["Repository"] = "Repository";
+  ObjectType2["Arb"] = "Arb";
+  ObjectType2["Arbitration"] = "Arbitration";
+  ObjectType2["Service"] = "Service";
+  ObjectType2["Machine"] = "Machine";
+  ObjectType2["Order"] = "Order";
+  ObjectType2["Progress"] = "Progress";
+  ObjectType2["Payment"] = "Payment";
+  ObjectType2["Treasury"] = "Treasury";
+  ObjectType2["Guard"] = "Guard";
+  ObjectType2["Demand"] = "Demand";
+  ObjectType2["Passport"] = "Passport";
+  ObjectType2["Allocation"] = "Allocation";
+  ObjectType2["Resource"] = "Resource";
+  ObjectType2["Reward"] = "Reward";
+  ObjectType2["Discount"] = "Discount";
+  ObjectType2["EntityRegistrar"] = "EntityRegistrar";
+  ObjectType2["EntityLinker"] = "EntityLinker";
+  ObjectType2["Proof"] = "Proof";
+  ObjectType2["Contact"] = "Contact";
+  ObjectType2["WReceivedObject"] = "WReceivedObject";
+  ObjectType2["TableItem_ProgressHistory"] = "TableItem_ProgressHistory";
+  ObjectType2["TableItem_PermissionPerm"] = "TableItem_PermissionPerm";
+  ObjectType2["TableItem_DemandPresenter"] = "TableItem_DemandPresenter";
+  ObjectType2["TableItem_MachineNode"] = "TableItem_MachineNode";
+  ObjectType2["TableItem_TreasuryHistory"] = "TableItem_TreasuryHistory";
+  ObjectType2["TableItem_RepositoryData"] = "TableItem_RepositoryData";
+  ObjectType2["TableItem_RewardRecord"] = "TableItem_RewardRecord";
+  ObjectType2["TableItem_EntityLinker"] = "TableItem_EntityLinker";
+  ObjectType2["TableItem_AddressMark"] = "TableItem_AddressMark";
+  ObjectType2["TableItem_EntityRegistrar"] = "TableItem_EntityRegistrar";
+  return ObjectType2;
+})(ObjectType || {});
+const ENTITY_LINKER_ADDRESS = "0xaaa";
+const ENTITY_REGISTRAR_ADDRESS = "0xaab";