wowok 1.8.2 → 2.1.9

package/dist/esm/w/common.js

@@ -0,0 +1,605 @@
+import { bcs } from "../bcs/index.js";
+import { W_ERROR, WErrors } from "./exception.js";
+import { LocalMark } from "./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 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)) {
+      W_ERROR(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)) {
+      W_ERROR(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)) {
+      W_ERROR(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)) {
+      W_ERROR(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)) {
+      W_ERROR(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)) {
+      W_ERROR(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) {
+      W_ERROR(
+        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) {
+      W_ERROR(
+        WErrors.NumberCountExceeded,
+        `Invalid U16Vec length: ${arg.length}`
+      );
+    }
+    return tx.pure.vector(
+      "u16",
+      arg.map((e) => {
+        if (!isValidU16(e)) {
+          W_ERROR(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 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";
+export {
+  CoinWrapPrefix,
+  ContextType,
+  ENTITY_LINKER_ADDRESS,
+  ENTITY_REGISTRAR_ADDRESS,
+  EntityAddress,
+  GasCoinType,
+  GasTokenType,
+  GetObject,
+  GetObjectDescription,
+  GetObjectExisted,
+  IsBcsStringLength,
+  IsValidArgType,
+  IsValidBalance,
+  IsValidEndpoint,
+  MAX_DEPENDED_COUNT,
+  MAX_DESCRIPTION_LENGTH,
+  MAX_ENV_PERMISSION_GUARD_COUNT,
+  MAX_GUARD_TABLE_ITEM_LENGTH,
+  MAX_INPUT_SIZE,
+  MAX_LONG_NAME_LENGTH,
+  MAX_MULTI_OPERANDS,
+  MAX_NAME_LENGTH,
+  MAX_PERMISSION_GUARD_COUNT,
+  MAX_TABLE_SIZE,
+  Modules,
+  ObjectType,
+  OperatorType,
+  PackageAddress,
+  RecipientType,
+  RegistrarAddress,
+  ValueType,
+  WitnessType,
+  arbitrationFn,
+  contactFn,
+  createValueContainer,
+  demandFn,
+  isGasTokenType,
+  isThisPackage,
+  isValidArray,
+  isValidDescription,
+  isValidHttpUrl,
+  isValidLongName,
+  isValidName,
+  isValidU128,
+  isValidU16,
+  isValidU256,
+  isValidU32,
+  isValidU64,
+  isValidU8,
+  isValidValueType,
+  isValidValueTypeInput,
+  isValueTypeNumber,
+  isWitnessType,
+  machineFn,
+  object_name_from_type,
+  parseValueType,
+  repositoryFn,
+  rewardFn,
+  serviceFn,
+  toTxAddress,
+  toTxAddressVec,
+  toTxObject,
+  toTxString,
+  toTxU128,
+  toTxU16,
+  toTxU16Vec,
+  toTxU256,
+  toTxU32,
+  toTxU64,
+  toTxU8,
+  treasuryFn,
+  valueTypeToString
+};

package/dist/esm/w/exception.d.ts

@@ -0,0 +1,82 @@
+export declare enum WErrors {
+    AccountNotFound = "account not found",
+    AddressNotFound = "address not found",
+    IsValidDescription = "invalid description",
+    IsValidName = "invalid name",
+    IsValidName_AllowEmpty = "invalid name",
+    IsValidEndpoint = "invalid endpoint",
+    IsValidAddress = "invalid address",
+    IsValidArgType = "invalid argument type",
+    IsValidTokenType = "invalid token type",
+    IsValidUint = "invalid uint",
+    IsValidInt = "invalid int",
+    IsValidU8 = "invalid u8",
+    IsValidU16 = "invalid u16",
+    IsValidU32 = "invalid u32",
+    IsValidU64 = "invalid u64",
+    IsValidU128 = "invalid u128",
+    IsValidU256 = "invalid u256",
+    IsValidRate = "invalid rate[0-10000]",
+    IsValidArray = "invalid array",
+    IsValidObjects = "invalid objects",
+    AllInvalid = "one valid at least",
+    InvalidParam = "invalid parameter",
+    IsValidPermissionIndex = "invalid permission index",
+    IsValidKey = "invalid key",
+    Fail = "fail",
+    IsValidIdentifier = "identifier invalid",
+    IsValidHttpUrl = "invalid url",
+    IsValidBizPermissionIndex = "invalid biz-permission id[1000 - 65535]",
+    BcsTypeInvalid = "invalid bcs type",
+    IsValidServiceItemName = "invalid service item name",
+    IsValidCoinType = "not the coin type",
+    IsValidGuardIdentifier = "guard identifier invalid",
+    NoPermission = "no permission",
+    IsValidValue = "invalid value",
+    IsValidValueType = "invalid value type",
+    IsValidLocation = "invalid location",
+    NetworkInvalid = "protocol network not specified",
+    WitnessTypeInvalid = "witness type invalid",
+    AddressCountExceeded = "address count exceeded",
+    NumberCountExceeded = "number count exceeded",
+    NewGuardCheckFailed = "new guard check failed",
+    GuardTableItemLengthExceeded = "guard table item length exceeded",
+    AccountPersistentStorageNotSet = "account persistent storage not set",
+    AccountPersistentStorageNotFound = "account persistent storage not found",
+    AccountNameExist = "account name exist",
+    ConfigPersistentStorageNotSet = "config persistent storage not set",
+    TokenNotFoundLocally = "token not found",
+    LocalMarkNameExist = "local mark name exist",
+    MaxObjectsPerQuery = "max objects per query",
+    ResourceTagCountExceeded = "resource tag count exceeded",
+    ParseObjectContentFailed = "parse object content failed"
+}
+export declare class WException extends Error {
+    readonly code: WErrors;
+    readonly details?: any;
+    constructor(error: WErrors, details?: any);
+    getErrorMessage(): string;
+    getErrorCode(): WErrors;
+    getDetails(): any;
+}
+export declare const W_ERROR: (error: WErrors, details?: any) => never;
+export type WResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: WException;
+};
+export declare const W_SUCCESS: <T>(data: T) => WResult<T>;
+export declare const W_FAILURE: (error: WErrors, details?: any) => WResult<any>;
+export declare function WValidate<T extends (...args: any[]) => any>(fn: T): T;
+export declare const W_SAFE: <T>(fn: () => T, error?: WErrors, details?: any) => WResult<T>;
+export declare const W_ENSURE: (condition: boolean, error: WErrors, details?: any) => void;
+export declare const W_VALIDATE_PARAM: (param: any, validator: (value: any) => boolean, error: WErrors, details?: any) => void;
+export interface MoveModuleError {
+    module: string;
+    code: number;
+    description: string;
+}
+export declare const MoveErrors: MoveModuleError[];
+export declare function getMoveErrorDescription(module: string, code: number): string | null;