wowok 2.1.13 → 2.1.16

package/dist/cjs/w/util.js

@@ -1,28 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRecipient = exports.uint2address = exports.validObjects = exports.extractCoinType = exports.parseTypeParameter = exports.parseObjectType = exports.bcsBytesToValue = exports.valueToBcsBytes = exports.isValidValueContainer = void 0;
-exports.owner_receive = owner_receive;
-exports.permission_set = permission_set;
-const index_js_1 = require("../bcs/index.js");
-const common_js_1 = require("./common.js");
-const exception_js_1 = require("./exception.js");
-const index_js_2 = require("./local/index.js");
-const common_js_2 = require("./common.js");
-const sui_types_js_1 = require("../utils/sui-types.js");
-const local_js_1 = require("./local/local.js");
-const local_js_2 = require("./local/local.js");
+import { bcs } from "../bcs/index.js";
+import { isThisPackage, IsValidArgType, isValidU128, isValidU16, isValidU256, isValidU32, isValidU64, isValidU8, isValidValueType, PackageAddress, ValueType, } from "./common.js";
+import { W_ERROR, WErrors } from "./exception.js";
+import { GetAccountOrMark_Address, GetManyAccountOrMark_Address, } from "./local/index.js";
+import { toTxObject } from "./common.js";
+import { normalizeWowAddress } from "../utils/sui-types.js";
+import { LocalMark } from "./local/local.js";
+import { isValidAddress } from "./local/local.js";
 // 验证 ValueContainer 的函数
-const isValidValueContainer = (container) => {
+export const isValidValueContainer = (container) => {
     try {
         // 通过尝试序列化来验证容器的有效性
-        (0, exports.valueToBcsBytes)(container.valueType, container.value);
+        valueToBcsBytes(container.valueType, container.value);
         return true;
     }
     catch {
         return false;
     }
 };
-exports.isValidValueContainer = isValidValueContainer;
 const toU64Value = (value) => {
     if (typeof value === "string") {
         if (value.length > 15) {
@@ -53,10 +47,10 @@ const toU256Value = (value) => {
     }
     return BigInt(value);
 };
-const valueToBcsBytes = async (valueType, value) => {
+export const valueToBcsBytes = async (valueType, value) => {
     // 验证 ValueType
-    if (!(0, common_js_1.isValidValueType)(valueType)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Invalid ValueType: ${valueType}`);
+    if (!isValidValueType(valueType)) {
+        W_ERROR(WErrors.InvalidParam, `Invalid ValueType: ${valueType}`);
         return new Uint8Array(0);
     }
     // 创建结果数组，第一个字节为 ValueType
@@ -65,16 +59,16 @@ const valueToBcsBytes = async (valueType, value) => {
     try {
         let serializedValue;
         switch (valueType) {
-            case common_js_1.ValueType.Bool:
-                serializedValue = index_js_1.bcs.Bool.serialize(value).toBytes();
+            case ValueType.Bool:
+                serializedValue = bcs.Bool.serialize(value).toBytes();
                 break;
-            case common_js_1.ValueType.Address: {
+            case ValueType.Address: {
                 let addressValue;
                 let errorDetails = "";
                 // 尝试不同的方式获取地址
                 if (typeof value === "string") {
                     // 如果是字符串，直接尝试解析
-                    addressValue = await (0, index_js_2.GetAccountOrMark_Address)({
+                    addressValue = await GetAccountOrMark_Address({
                         name_or_address: value,
                     });
                     errorDetails = `string: ${value}`;
@@ -85,7 +79,7 @@ const valueToBcsBytes = async (valueType, value) => {
                     // 如果是包含name_or_address属性的对象
                     const accountOrMarkAddr = value;
                     addressValue =
-                        await (0, index_js_2.GetAccountOrMark_Address)(accountOrMarkAddr);
+                        await GetAccountOrMark_Address(accountOrMarkAddr);
                     errorDetails = `AccountOrMark_Address: ${JSON.stringify(value)}`;
                 }
                 else {
@@ -94,217 +88,217 @@ const valueToBcsBytes = async (valueType, value) => {
                     errorDetails = `type: ${typeof value}, value: ${JSON.stringify(value)}`;
                 }
                 if (addressValue === undefined) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid Address for ValueType.Address, but failed to resolve ${errorDetails}. Address may not exist in local accounts or marks.`);
+                    W_ERROR(WErrors.InvalidParam, `Expected valid Address for ValueType.Address, but failed to resolve ${errorDetails}. Address may not exist in local accounts or marks.`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.Address.serialize(addressValue).toBytes();
+                serializedValue = bcs.Address.serialize(addressValue).toBytes();
                 break;
             }
-            case common_js_1.ValueType.String:
-                serializedValue = index_js_1.bcs.String.serialize(value).toBytes();
+            case ValueType.String:
+                serializedValue = bcs.String.serialize(value).toBytes();
                 break;
-            case common_js_1.ValueType.U8:
-                if (!(0, common_js_1.isValidU8)(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U8 for ValueType.U8, got ${JSON.stringify(value)}`);
+            case ValueType.U8:
+                if (!isValidU8(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected valid U8 for ValueType.U8, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.U8.serialize(value).toBytes();
+                serializedValue = bcs.U8.serialize(value).toBytes();
                 break;
-            case common_js_1.ValueType.U16:
-                if (!(0, common_js_1.isValidU16)(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U16 for ValueType.U16, got ${JSON.stringify(value)}`);
+            case ValueType.U16:
+                if (!isValidU16(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected valid U16 for ValueType.U16, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.U16.serialize(value).toBytes();
+                serializedValue = bcs.U16.serialize(value).toBytes();
                 break;
-            case common_js_1.ValueType.U32:
-                if (!(0, common_js_1.isValidU32)(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U32 for ValueType.U32, got ${JSON.stringify(value)}`);
+            case ValueType.U32:
+                if (!isValidU32(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected valid U32 for ValueType.U32, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.U32.serialize(value).toBytes();
+                serializedValue = bcs.U32.serialize(value).toBytes();
                 break;
-            case common_js_1.ValueType.U64:
-                if (!(0, common_js_1.isValidU64)(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U64 for ValueType.U64, got ${JSON.stringify(value)}`);
+            case ValueType.U64:
+                if (!isValidU64(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected valid U64 for ValueType.U64, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.U64.serialize(toU64Value(value)).toBytes();
+                serializedValue = bcs.U64.serialize(toU64Value(value)).toBytes();
                 break;
-            case common_js_1.ValueType.U128:
-                if (!(0, common_js_1.isValidU128)(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U128 for ValueType.U128, got ${JSON.stringify(value)}`);
+            case ValueType.U128:
+                if (!isValidU128(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected valid U128 for ValueType.U128, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.U128.serialize(toU128Value(value)).toBytes();
+                serializedValue = bcs.U128.serialize(toU128Value(value)).toBytes();
                 break;
-            case common_js_1.ValueType.U256:
-                if (!(0, common_js_1.isValidU256)(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U256 for ValueType.U256, got ${JSON.stringify(value)}`);
+            case ValueType.U256:
+                if (!isValidU256(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected valid U256 for ValueType.U256, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
-                serializedValue = index_js_1.bcs.U256.serialize(toU256Value(value)).toBytes();
+                serializedValue = bcs.U256.serialize(toU256Value(value)).toBytes();
                 break;
-            case common_js_1.ValueType.VecBool:
+            case ValueType.VecBool:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecBool, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecBool, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
                     if (typeof item !== "boolean") {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected boolean in VecBool, got ${typeof item}`);
+                        W_ERROR(WErrors.InvalidParam, `Expected boolean in VecBool, got ${typeof item}`);
                         return new Uint8Array(0);
                     }
                 }
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.Bool)
+                serializedValue = bcs
+                    .vector(bcs.Bool)
                     .serialize(value)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecAddress:
-                const r = await (0, index_js_2.GetManyAccountOrMark_Address)(value);
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.Address)
+            case ValueType.VecAddress:
+                const r = await GetManyAccountOrMark_Address(value);
+                serializedValue = bcs
+                    .vector(bcs.Address)
                     .serialize(r)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecString:
+            case ValueType.VecString:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecString, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecString, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
                     if (typeof item !== "string") {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected string in VecString, got ${typeof item}`);
+                        W_ERROR(WErrors.InvalidParam, `Expected string in VecString, got ${typeof item}`);
                         return new Uint8Array(0);
                     }
                 }
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.String)
+                serializedValue = bcs
+                    .vector(bcs.String)
                     .serialize(value)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecU8:
+            case ValueType.VecU8:
                 if (value instanceof Uint8Array) {
-                    serializedValue = index_js_1.bcs
-                        .vector(index_js_1.bcs.U8)
+                    serializedValue = bcs
+                        .vector(bcs.U8)
                         .serialize(Array.from(value))
                         .toBytes();
                 }
                 else if (Array.isArray(value)) {
                     for (const item of value) {
-                        if (!(0, common_js_1.isValidU8)(item)) {
-                            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U8 in VecU8, got ${item}`);
+                        if (!isValidU8(item)) {
+                            W_ERROR(WErrors.InvalidParam, `Expected valid U8 in VecU8, got ${item}`);
                             return new Uint8Array(0);
                         }
                     }
-                    serializedValue = index_js_1.bcs
-                        .vector(index_js_1.bcs.U8)
+                    serializedValue = bcs
+                        .vector(bcs.U8)
                         .serialize(value)
                         .toBytes();
                 }
                 else {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected Uint8Array or array for ValueType.VecU8, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected Uint8Array or array for ValueType.VecU8, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 break;
-            case common_js_1.ValueType.VecU16:
+            case ValueType.VecU16:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecU16, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU16, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
-                    if (!(0, common_js_1.isValidU16)(item)) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U16 in VecU16, got ${item}`);
+                    if (!isValidU16(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U16 in VecU16, got ${item}`);
                         return new Uint8Array(0);
                     }
                 }
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.U16)
+                serializedValue = bcs
+                    .vector(bcs.U16)
                     .serialize(value)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecU32:
+            case ValueType.VecU32:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecU32, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU32, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
-                    if (!(0, common_js_1.isValidU32)(item)) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U32 in VecU32, got ${item}`);
+                    if (!isValidU32(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U32 in VecU32, got ${item}`);
                         return new Uint8Array(0);
                     }
                 }
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.U32)
+                serializedValue = bcs
+                    .vector(bcs.U32)
                     .serialize(value)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecU64:
+            case ValueType.VecU64:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecU64, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU64, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
-                    if (!(0, common_js_1.isValidU64)(item)) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U64 in VecU64, got ${item}`);
+                    if (!isValidU64(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U64 in VecU64, got ${item}`);
                         return new Uint8Array(0);
                     }
                 }
                 const vecU64Values = value.map(toU64Value);
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.U64)
+                serializedValue = bcs
+                    .vector(bcs.U64)
                     .serialize(vecU64Values)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecU128:
+            case ValueType.VecU128:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecU128, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU128, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
-                    if (!(0, common_js_1.isValidU128)(item)) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U128 in VecU128, got ${item}`);
+                    if (!isValidU128(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U128 in VecU128, got ${item}`);
                         return new Uint8Array(0);
                     }
                 }
                 const vecU128Values = value.map(toU128Value);
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.U128)
+                serializedValue = bcs
+                    .vector(bcs.U128)
                     .serialize(vecU128Values)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecU256:
+            case ValueType.VecU256:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecU256, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU256, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
-                    if (!(0, common_js_1.isValidU256)(item)) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U256 in VecU256, got ${item}`);
+                    if (!isValidU256(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U256 in VecU256, got ${item}`);
                         return new Uint8Array(0);
                     }
                 }
                 const vecU256Values = value.map(toU256Value);
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.U256)
+                serializedValue = bcs
+                    .vector(bcs.U256)
                     .serialize(vecU256Values)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.VecVecU8:
+            case ValueType.VecVecU8:
                 if (!Array.isArray(value)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected array for ValueType.VecVecU8, got ${typeof value}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecVecU8, got ${typeof value}`);
                     return new Uint8Array(0);
                 }
                 for (const item of value) {
                     if (!(item instanceof Uint8Array || Array.isArray(item))) {
-                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected Uint8Array or array in VecVecU8, got ${typeof item}`);
+                        W_ERROR(WErrors.InvalidParam, `Expected Uint8Array or array in VecVecU8, got ${typeof item}`);
                         return new Uint8Array(0);
                     }
                     if (Array.isArray(item)) {
                         for (const subItem of item) {
-                            if (!(0, common_js_1.isValidU8)(subItem)) {
-                                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected valid U8 in VecVecU8, got ${subItem}`);
+                            if (!isValidU8(subItem)) {
+                                W_ERROR(WErrors.InvalidParam, `Expected valid U8 in VecVecU8, got ${subItem}`);
                                 return new Uint8Array(0);
                             }
                         }
@@ -312,12 +306,12 @@ const valueToBcsBytes = async (valueType, value) => {
                 }
                 // 将 Uint8Array 转换为数组
                 const vecVecU8 = value.map((item) => item instanceof Uint8Array ? Array.from(item) : item);
-                serializedValue = index_js_1.bcs
-                    .vector(index_js_1.bcs.vector(index_js_1.bcs.U8))
+                serializedValue = bcs
+                    .vector(bcs.vector(bcs.U8))
                     .serialize(vecVecU8)
                     .toBytes();
                 break;
-            case common_js_1.ValueType.Value:
+            case ValueType.Value:
                 // Value 类型是递归的，包含一个 ValueContainer
                 // 第一个字节是内部的 ValueType，后续字节是 BCS 序列化的值
                 const container = value;
@@ -325,19 +319,19 @@ const valueToBcsBytes = async (valueType, value) => {
                     typeof container !== "object" ||
                     !("valueType" in container) ||
                     !("value" in container)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Expected ValueContainer for ValueType.Value, got ${JSON.stringify(value)}`);
+                    W_ERROR(WErrors.InvalidParam, `Expected ValueContainer for ValueType.Value, got ${JSON.stringify(value)}`);
                     return new Uint8Array(0);
                 }
                 // 验证内部的 valueType 是否有效
-                if (!(0, common_js_1.isValidValueType)(container.valueType)) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Invalid inner ValueType in ValueContainer: ${container.valueType}`);
+                if (!isValidValueType(container.valueType)) {
+                    W_ERROR(WErrors.InvalidParam, `Invalid inner ValueType in ValueContainer: ${container.valueType}`);
                     return new Uint8Array(0);
                 }
                 // 递归序列化内部值
-                serializedValue = await (0, exports.valueToBcsBytes)(container.valueType, container.value);
+                serializedValue = await valueToBcsBytes(container.valueType, container.value);
                 break;
             default:
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Unsupported ValueType: ${valueType}`);
+                W_ERROR(WErrors.InvalidParam, `Unsupported ValueType: ${valueType}`);
                 return new Uint8Array(0);
         }
         // 合并结果
@@ -347,22 +341,21 @@ const valueToBcsBytes = async (valueType, value) => {
         return finalResult;
     }
     catch (error) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `BCS serialization failed: ${error.message}`);
+        W_ERROR(WErrors.InvalidParam, `BCS serialization failed: ${error.message}`);
         return new Uint8Array(0);
     }
 };
-exports.valueToBcsBytes = valueToBcsBytes;
 // 类型安全的反序列化函数
-const bcsBytesToValue = (bytes, valueType) => {
+export const bcsBytesToValue = (bytes, valueType) => {
     if (bytes.length === 0) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "Empty bytes array");
+        W_ERROR(WErrors.InvalidParam, "Empty bytes array");
         return undefined;
     }
     // 获取 ValueType
     const actualValueType = valueType ?? bytes[0];
     // 验证 ValueType
-    if (!(0, common_js_1.isValidValueType)(actualValueType)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Invalid ValueType in bytes: ${actualValueType}`);
+    if (!isValidValueType(actualValueType)) {
+        W_ERROR(WErrors.InvalidParam, `Invalid ValueType in bytes: ${actualValueType}`);
         return undefined;
     }
     if (bytes.length < 2) {
@@ -372,63 +365,62 @@ const bcsBytesToValue = (bytes, valueType) => {
     const dataBytes = bytes.slice(1);
     try {
         switch (actualValueType) {
-            case common_js_1.ValueType.Bool:
-                return index_js_1.bcs.Bool.parse(dataBytes);
-            case common_js_1.ValueType.Address:
-                return index_js_1.bcs.Address.parse(dataBytes);
-            case common_js_1.ValueType.String:
-                return index_js_1.bcs.String.parse(dataBytes);
-            case common_js_1.ValueType.U8:
-                return index_js_1.bcs.U8.parse(dataBytes);
-            case common_js_1.ValueType.U16:
-                return index_js_1.bcs.U16.parse(dataBytes);
-            case common_js_1.ValueType.U32:
-                return index_js_1.bcs.U32.parse(dataBytes);
-            case common_js_1.ValueType.U64:
-                return index_js_1.bcs.U64.parse(dataBytes);
-            case common_js_1.ValueType.U128:
-                return index_js_1.bcs.U128.parse(dataBytes);
-            case common_js_1.ValueType.U256:
-                return index_js_1.bcs.U256.parse(dataBytes);
-            case common_js_1.ValueType.VecBool:
-                return index_js_1.bcs.vector(index_js_1.bcs.Bool).parse(dataBytes);
-            case common_js_1.ValueType.VecAddress:
-                const addresses = index_js_1.bcs.vector(index_js_1.bcs.Address).parse(dataBytes);
+            case ValueType.Bool:
+                return bcs.Bool.parse(dataBytes);
+            case ValueType.Address:
+                return bcs.Address.parse(dataBytes);
+            case ValueType.String:
+                return bcs.String.parse(dataBytes);
+            case ValueType.U8:
+                return bcs.U8.parse(dataBytes);
+            case ValueType.U16:
+                return bcs.U16.parse(dataBytes);
+            case ValueType.U32:
+                return bcs.U32.parse(dataBytes);
+            case ValueType.U64:
+                return bcs.U64.parse(dataBytes);
+            case ValueType.U128:
+                return bcs.U128.parse(dataBytes);
+            case ValueType.U256:
+                return bcs.U256.parse(dataBytes);
+            case ValueType.VecBool:
+                return bcs.vector(bcs.Bool).parse(dataBytes);
+            case ValueType.VecAddress:
+                const addresses = bcs.vector(bcs.Address).parse(dataBytes);
                 return {
                     entities: addresses.map((addr) => ({
                         name_or_address: addr,
                     })),
                 };
-            case common_js_1.ValueType.VecString:
-                return index_js_1.bcs.vector(index_js_1.bcs.String).parse(dataBytes);
-            case common_js_1.ValueType.VecU8:
-                return index_js_1.bcs.vector(index_js_1.bcs.U8).parse(dataBytes);
-            case common_js_1.ValueType.VecU16:
-                return index_js_1.bcs.vector(index_js_1.bcs.U16).parse(dataBytes);
-            case common_js_1.ValueType.VecU32:
-                return index_js_1.bcs.vector(index_js_1.bcs.U32).parse(dataBytes);
-            case common_js_1.ValueType.VecU64:
-                return index_js_1.bcs.vector(index_js_1.bcs.U64).parse(dataBytes);
-            case common_js_1.ValueType.VecU128:
-                return index_js_1.bcs.vector(index_js_1.bcs.U128).parse(dataBytes);
-            case common_js_1.ValueType.VecU256:
-                return index_js_1.bcs.vector(index_js_1.bcs.U256).parse(dataBytes);
-            case common_js_1.ValueType.VecVecU8:
-                return index_js_1.bcs.vector(index_js_1.bcs.vector(index_js_1.bcs.U8)).parse(dataBytes);
+            case ValueType.VecString:
+                return bcs.vector(bcs.String).parse(dataBytes);
+            case ValueType.VecU8:
+                return bcs.vector(bcs.U8).parse(dataBytes);
+            case ValueType.VecU16:
+                return bcs.vector(bcs.U16).parse(dataBytes);
+            case ValueType.VecU32:
+                return bcs.vector(bcs.U32).parse(dataBytes);
+            case ValueType.VecU64:
+                return bcs.vector(bcs.U64).parse(dataBytes);
+            case ValueType.VecU128:
+                return bcs.vector(bcs.U128).parse(dataBytes);
+            case ValueType.VecU256:
+                return bcs.vector(bcs.U256).parse(dataBytes);
+            case ValueType.VecVecU8:
+                return bcs.vector(bcs.vector(bcs.U8)).parse(dataBytes);
             default:
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Unsupported ValueType for deserialization: ${actualValueType}`);
+                W_ERROR(WErrors.InvalidParam, `Unsupported ValueType for deserialization: ${actualValueType}`);
                 return undefined;
         }
     }
     catch (error) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `BCS deserialization failed: ${error.message}`);
+        W_ERROR(WErrors.InvalidParam, `BCS deserialization failed: ${error.message}`);
         return undefined;
     }
 };
-exports.bcsBytesToValue = bcsBytesToValue;
-const parseObjectType = (chain_type, header = "payment::Payment") => {
+export const parseObjectType = (chain_type, header = "payment::Payment") => {
     header += "<";
-    if (chain_type && (0, common_js_1.isThisPackage)(chain_type)) {
+    if (chain_type && isThisPackage(chain_type)) {
         const i = chain_type.indexOf(header);
         if (i > 0) {
             const r = chain_type.slice(i + header.length, chain_type.length - 1);
@@ -437,9 +429,8 @@ const parseObjectType = (chain_type, header = "payment::Payment") => {
     }
     return undefined;
 };
-exports.parseObjectType = parseObjectType;
-const parseTypeParameter = (type) => {
-    if (!type || !type.startsWith(common_js_1.PackageAddress)) {
+export const parseTypeParameter = (type) => {
+    if (!type || !type.startsWith(PackageAddress)) {
         return undefined;
     }
     const openIndex = type.indexOf("<");
@@ -449,13 +440,12 @@ const parseTypeParameter = (type) => {
     }
     return type.slice(openIndex + 1, closeIndex);
 };
-exports.parseTypeParameter = parseTypeParameter;
-const extractCoinType = (type) => {
-    if (!type || !type.startsWith(common_js_1.PackageAddress)) {
+export const extractCoinType = (type) => {
+    if (!type || !type.startsWith(PackageAddress)) {
         return undefined;
     }
     // Match the pattern: PackageAddress::{}::{}<PackageAddress::coin::Coin<{}>>
-    const escapedPackageAddress = common_js_1.PackageAddress.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const escapedPackageAddress = PackageAddress.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const coinPattern = new RegExp(`${escapedPackageAddress}::[^:]+::[^<]+<${escapedPackageAddress}::coin::Coin<([^>]+)>>`);
     const match = type.match(coinPattern);
     if (match && match[1]) {
@@ -463,32 +453,31 @@ const extractCoinType = (type) => {
     }
     return undefined;
 };
-exports.extractCoinType = extractCoinType;
-async function owner_receive(tx, object, // MachineObject | DemandObject | ServiceObject ...
+export async function owner_receive(tx, object, // MachineObject | DemandObject | ServiceObject ...
 permission, param, caller_type, fnBuilder, // machineFn | demandFn
 passport) {
-    (0, exports.validObjects)([object, permission, passport]);
-    if (caller_type && !(0, common_js_1.IsValidArgType)(caller_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `caller_type ${caller_type} is invalid`);
+    validObjects([object, permission, passport]);
+    if (caller_type && !IsValidArgType(caller_type)) {
+        W_ERROR(WErrors.IsValidArgType, `caller_type ${caller_type} is invalid`);
     }
     // 处理ReceivedNormal[]类型
     if (Array.isArray(param)) {
         for (const item of param) {
-            if (!item.type || !(0, common_js_1.IsValidArgType)(item.type)) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `type ${item.type} is invalid`);
+            if (!item.type || !IsValidArgType(item.type)) {
+                W_ERROR(WErrors.IsValidArgType, `type ${item.type} is invalid`);
             }
             if (passport) {
-                const r = await local_js_1.LocalMark.Instance().get_address(item.id);
+                const r = await LocalMark.Instance().get_address(item.id);
                 if (!r) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Received ${item.id} is invalid`);
+                    W_ERROR(WErrors.IsValidArgType, `Received ${item.id} is invalid`);
                 }
                 tx.moveCall({
                     target: fnBuilder("owner_receive_object_with_passport"),
                     arguments: [
-                        (0, common_js_2.toTxObject)(tx, object),
-                        (0, common_js_2.toTxObject)(tx, permission),
-                        (0, common_js_2.toTxObject)(tx, passport),
-                        (0, common_js_2.toTxObject)(tx, r),
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, passport),
+                        toTxObject(tx, r),
                     ],
                     typeArguments: caller_type
                         ? [caller_type, item.type]
@@ -496,16 +485,16 @@ passport) {
                 });
             }
             else {
-                const r = await local_js_1.LocalMark.Instance().get_address(item.id);
+                const r = await LocalMark.Instance().get_address(item.id);
                 if (!r) {
-                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Received ${item.id} is invalid`);
+                    W_ERROR(WErrors.IsValidArgType, `Received ${item.id} is invalid`);
                 }
                 tx.moveCall({
                     target: fnBuilder("owner_receive_object"),
                     arguments: [
-                        (0, common_js_2.toTxObject)(tx, object),
-                        (0, common_js_2.toTxObject)(tx, permission),
-                        (0, common_js_2.toTxObject)(tx, r),
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, r),
                     ],
                     typeArguments: caller_type
                         ? [caller_type, item.type]
@@ -518,31 +507,31 @@ passport) {
     else {
         const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
         if (!match) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${param.token_type}`);
+            W_ERROR(WErrors.IsValidArgType, `Invalid CoinWrapper type: ${param.token_type}`);
         }
         const t = match[1];
-        if (!(0, common_js_1.IsValidArgType)(t)) {
-            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+        if (!IsValidArgType(t)) {
+            W_ERROR(WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
         }
         for (const item of param.received) {
             // 这里假设item.type是CoinWrapper类型
             // 从item.id和item.payment中获取地址
             const [r, p] = await Promise.all([
-                local_js_1.LocalMark.Instance().get_address(item.id),
-                local_js_1.LocalMark.Instance().get_address(item.payment),
+                LocalMark.Instance().get_address(item.id),
+                LocalMark.Instance().get_address(item.payment),
             ]);
             if (!r || !p) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `Received ${item.id} or Payment ${item.payment} is invalid`);
+                W_ERROR(WErrors.IsValidArgType, `Received ${item.id} or Payment ${item.payment} is invalid`);
             }
             if (passport) {
                 tx.moveCall({
                     target: fnBuilder("owner_receive_with_passport"),
                     arguments: [
-                        (0, common_js_2.toTxObject)(tx, object),
-                        (0, common_js_2.toTxObject)(tx, permission),
-                        (0, common_js_2.toTxObject)(tx, passport),
-                        (0, common_js_2.toTxObject)(tx, r),
-                        (0, common_js_2.toTxObject)(tx, p),
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, passport),
+                        toTxObject(tx, r),
+                        toTxObject(tx, p),
                     ],
                     typeArguments: caller_type ? [caller_type, t] : [t],
                 });
@@ -551,10 +540,10 @@ passport) {
                 tx.moveCall({
                     target: fnBuilder("owner_receive"),
                     arguments: [
-                        (0, common_js_2.toTxObject)(tx, object),
-                        (0, common_js_2.toTxObject)(tx, permission),
-                        (0, common_js_2.toTxObject)(tx, r),
-                        (0, common_js_2.toTxObject)(tx, p),
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, r),
+                        toTxObject(tx, p),
                     ],
                     typeArguments: caller_type ? [caller_type, t] : [t],
                 });
@@ -562,47 +551,45 @@ passport) {
         }
     }
 }
-function permission_set(tx, object, // MachineObject | DemandObject
+export function permission_set(tx, object, // MachineObject | DemandObject
 old_permission, new_permission, caller_type, fnBuilder) {
-    (0, exports.validObjects)([object, old_permission, new_permission]);
-    if (caller_type && !(0, common_js_1.IsValidArgType)(caller_type)) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `caller_type ${caller_type} is invalid`);
+    validObjects([object, old_permission, new_permission]);
+    if (caller_type && !IsValidArgType(caller_type)) {
+        W_ERROR(WErrors.IsValidArgType, `caller_type ${caller_type} is invalid`);
     }
     tx.moveCall({
         target: fnBuilder("permission_set"),
         arguments: [
-            (0, common_js_2.toTxObject)(tx, object),
-            (0, common_js_2.toTxObject)(tx, old_permission),
-            (0, common_js_2.toTxObject)(tx, new_permission),
+            toTxObject(tx, object),
+            toTxObject(tx, old_permission),
+            toTxObject(tx, new_permission),
             tx.object.mutRegistrar(),
             tx.object.clock(),
         ],
         typeArguments: caller_type ? [caller_type] : [],
     });
 }
-const validObjects = (objects, allowNull = true) => {
+export const validObjects = (objects, allowNull = true) => {
     objects.forEach((item, index) => {
         if (typeof item === "string" && item != null) {
-            if (!(0, local_js_2.isValidAddress)(item)) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `Address is invalid: ${item}`);
+            if (!isValidAddress(item)) {
+                W_ERROR(WErrors.IsValidAddress, `Address is invalid: ${item}`);
             }
         }
         else {
             if (!allowNull && !item) {
-                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `Address is required at index ${index} in objects ${objects}`);
+                W_ERROR(WErrors.IsValidAddress, `Address is required at index ${index} in objects ${objects}`);
             }
         }
     });
 };
-exports.validObjects = validObjects;
-const uint2address = (value) => {
-    return (0, sui_types_js_1.normalizeWowAddress)(value.toString(16));
+export const uint2address = (value) => {
+    return normalizeWowAddress(value.toString(16));
 };
-exports.uint2address = uint2address;
 // 将 whoData 转换为 Recipient 类型
-const parseRecipient = (whoData) => {
+export const parseRecipient = (whoData) => {
     if (!whoData || !whoData.variant) {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.ParseObjectContentFailed, `Invalid who data: ${JSON.stringify(whoData)}`);
+        W_ERROR(WErrors.ParseObjectContentFailed, `Invalid who data: ${JSON.stringify(whoData)}`);
     }
     if (whoData.variant === "GuardIdentifier" && whoData.fields) {
         return {
@@ -622,8 +609,7 @@ const parseRecipient = (whoData) => {
         };
     }
     else {
-        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.ParseObjectContentFailed, `Invalid who variant: ${whoData.variant}`);
+        W_ERROR(WErrors.ParseObjectContentFailed, `Invalid who variant: ${whoData.variant}`);
     }
 };
-exports.parseRecipient = parseRecipient;
 //# sourceMappingURL=util.js.map