wowok 2.1.9 → 2.1.12

package/dist/esm/w/util.js

@@ -1,710 +1,615 @@
 import { bcs } from "../bcs/index.js";
-import {
-  isThisPackage,
-  IsValidArgType,
-  isValidU128,
-  isValidU16,
-  isValidU256,
-  isValidU32,
-  isValidU64,
-  isValidU8,
-  isValidValueType,
-  PackageAddress,
-  ValueType
-} from "./common.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 { 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";
-const isValidValueContainer = (container) => {
-  try {
-    valueToBcsBytes(container.valueType, container.value);
-    return true;
-  } catch {
-    return false;
-  }
+// 验证 ValueContainer 的函数
+export const isValidValueContainer = (container) => {
+    try {
+        // 通过尝试序列化来验证容器的有效性
+        valueToBcsBytes(container.valueType, container.value);
+        return true;
+    }
+    catch {
+        return false;
+    }
 };
 const toU64Value = (value) => {
-  if (typeof value === "string") {
-    if (value.length > 15) {
-      return BigInt(value);
-    } else {
-      const num = parseInt(value, 10);
-      return Number.isInteger(num) ? num : BigInt(value);
+    if (typeof value === "string") {
+        if (value.length > 15) {
+            return BigInt(value);
+        }
+        else {
+            const num = parseInt(value, 10);
+            return Number.isInteger(num) ? num : BigInt(value);
+        }
     }
-  }
-  return value;
+    return value;
 };
 const toU128Value = (value) => {
-  if (typeof value === "bigint") {
-    return value;
-  }
-  if (typeof value === "string") {
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return BigInt(value);
+    }
     return BigInt(value);
-  }
-  return BigInt(value);
 };
 const toU256Value = (value) => {
-  if (typeof value === "bigint") {
-    return value;
-  }
-  if (typeof value === "string") {
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return BigInt(value);
+    }
     return BigInt(value);
-  }
-  return BigInt(value);
 };
-const valueToBcsBytes = async (valueType, value) => {
-  if (!isValidValueType(valueType)) {
-    W_ERROR(WErrors.InvalidParam, `Invalid ValueType: ${valueType}`);
-    return new Uint8Array(0);
-  }
-  const result = new Uint8Array(1);
-  result[0] = valueType;
-  try {
-    let serializedValue;
-    switch (valueType) {
-      case ValueType.Bool:
-        serializedValue = bcs.Bool.serialize(
-          value
-        ).toBytes();
-        break;
-      case ValueType.Address: {
-        let addressValue;
-        let errorDetails = "";
-        if (typeof value === "string") {
-          addressValue = await GetAccountOrMark_Address({
-            name_or_address: value
-          });
-          errorDetails = `string: ${value}`;
-        } else if (value && typeof value === "object" && "name_or_address" in value) {
-          const accountOrMarkAddr = value;
-          addressValue = await GetAccountOrMark_Address(accountOrMarkAddr);
-          errorDetails = `AccountOrMark_Address: ${JSON.stringify(value)}`;
-        } else {
-          addressValue = void 0;
-          errorDetails = `type: ${typeof value}, value: ${JSON.stringify(value)}`;
-        }
-        if (addressValue === void 0) {
-          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 = bcs.Address.serialize(addressValue).toBytes();
-        break;
-      }
-      case ValueType.String:
-        serializedValue = bcs.String.serialize(
-          value
-        ).toBytes();
-        break;
-      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 = bcs.U8.serialize(value).toBytes();
-        break;
-      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 = bcs.U16.serialize(value).toBytes();
-        break;
-      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 = bcs.U32.serialize(value).toBytes();
-        break;
-      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 = bcs.U64.serialize(
-          toU64Value(value)
-        ).toBytes();
-        break;
-      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 = bcs.U128.serialize(
-          toU128Value(value)
-        ).toBytes();
-        break;
-      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 = bcs.U256.serialize(
-          toU256Value(value)
-        ).toBytes();
-        break;
-      case ValueType.VecBool:
-        if (!Array.isArray(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") {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected boolean in VecBool, got ${typeof item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = bcs.vector(bcs.Bool).serialize(value).toBytes();
-        break;
-      case ValueType.VecAddress:
-        const r = await GetManyAccountOrMark_Address(
-          value
-        );
-        serializedValue = bcs.vector(bcs.Address).serialize(r).toBytes();
-        break;
-      case ValueType.VecString:
-        if (!Array.isArray(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") {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected string in VecString, got ${typeof item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = bcs.vector(bcs.String).serialize(value).toBytes();
-        break;
-      case ValueType.VecU8:
-        if (value instanceof Uint8Array) {
-          serializedValue = bcs.vector(bcs.U8).serialize(Array.from(value)).toBytes();
-        } else if (Array.isArray(value)) {
-          for (const item of value) {
-            if (!isValidU8(item)) {
-              W_ERROR(
-                WErrors.InvalidParam,
-                `Expected valid U8 in VecU8, got ${item}`
-              );
-              return new Uint8Array(0);
+export const valueToBcsBytes = async (valueType, value) => {
+    // 验证 ValueType
+    if (!isValidValueType(valueType)) {
+        W_ERROR(WErrors.InvalidParam, `Invalid ValueType: ${valueType}`);
+        return new Uint8Array(0);
+    }
+    // 创建结果数组，第一个字节为 ValueType
+    const result = new Uint8Array(1);
+    result[0] = valueType;
+    try {
+        let serializedValue;
+        switch (valueType) {
+            case ValueType.Bool:
+                serializedValue = bcs.Bool.serialize(value).toBytes();
+                break;
+            case ValueType.Address: {
+                let addressValue;
+                let errorDetails = "";
+                // 尝试不同的方式获取地址
+                if (typeof value === "string") {
+                    // 如果是字符串，直接尝试解析
+                    addressValue = await GetAccountOrMark_Address({
+                        name_or_address: value,
+                    });
+                    errorDetails = `string: ${value}`;
+                }
+                else if (value &&
+                    typeof value === "object" &&
+                    "name_or_address" in value) {
+                    // 如果是包含name_or_address属性的对象
+                    const accountOrMarkAddr = value;
+                    addressValue =
+                        await GetAccountOrMark_Address(accountOrMarkAddr);
+                    errorDetails = `AccountOrMark_Address: ${JSON.stringify(value)}`;
+                }
+                else {
+                    // 其他类型
+                    addressValue = undefined;
+                    errorDetails = `type: ${typeof value}, value: ${JSON.stringify(value)}`;
+                }
+                if (addressValue === undefined) {
+                    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 = bcs.Address.serialize(addressValue).toBytes();
+                break;
             }
-          }
-          serializedValue = bcs.vector(bcs.U8).serialize(value).toBytes();
-        } else {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected Uint8Array or array for ValueType.VecU8, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        break;
-      case ValueType.VecU16:
-        if (!Array.isArray(value)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected array for ValueType.VecU16, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!isValidU16(item)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected valid U16 in VecU16, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = bcs.vector(bcs.U16).serialize(value).toBytes();
-        break;
-      case ValueType.VecU32:
-        if (!Array.isArray(value)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected array for ValueType.VecU32, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!isValidU32(item)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected valid U32 in VecU32, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = bcs.vector(bcs.U32).serialize(value).toBytes();
-        break;
-      case ValueType.VecU64:
-        if (!Array.isArray(value)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected array for ValueType.VecU64, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!isValidU64(item)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected valid U64 in VecU64, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        const vecU64Values = value.map(toU64Value);
-        serializedValue = bcs.vector(bcs.U64).serialize(vecU64Values).toBytes();
-        break;
-      case ValueType.VecU128:
-        if (!Array.isArray(value)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected array for ValueType.VecU128, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!isValidU128(item)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected valid U128 in VecU128, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        const vecU128Values = value.map(toU128Value);
-        serializedValue = bcs.vector(bcs.U128).serialize(vecU128Values).toBytes();
-        break;
-      case ValueType.VecU256:
-        if (!Array.isArray(value)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected array for ValueType.VecU256, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!isValidU256(item)) {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `Expected valid U256 in VecU256, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        const vecU256Values = value.map(toU256Value);
-        serializedValue = bcs.vector(bcs.U256).serialize(vecU256Values).toBytes();
-        break;
-      case ValueType.VecVecU8:
-        if (!Array.isArray(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))) {
-            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 (!isValidU8(subItem)) {
-                W_ERROR(
-                  WErrors.InvalidParam,
-                  `Expected valid U8 in VecVecU8, got ${subItem}`
-                );
+            case ValueType.String:
+                serializedValue = bcs.String.serialize(value).toBytes();
+                break;
+            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 = bcs.U8.serialize(value).toBytes();
+                break;
+            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 = bcs.U16.serialize(value).toBytes();
+                break;
+            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 = bcs.U32.serialize(value).toBytes();
+                break;
+            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 = bcs.U64.serialize(toU64Value(value)).toBytes();
+                break;
+            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 = bcs.U128.serialize(toU128Value(value)).toBytes();
+                break;
+            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 = bcs.U256.serialize(toU256Value(value)).toBytes();
+                break;
+            case ValueType.VecBool:
+                if (!Array.isArray(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") {
+                        W_ERROR(WErrors.InvalidParam, `Expected boolean in VecBool, got ${typeof item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = bcs
+                    .vector(bcs.Bool)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case ValueType.VecAddress:
+                const r = await GetManyAccountOrMark_Address(value);
+                serializedValue = bcs
+                    .vector(bcs.Address)
+                    .serialize(r)
+                    .toBytes();
+                break;
+            case ValueType.VecString:
+                if (!Array.isArray(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") {
+                        W_ERROR(WErrors.InvalidParam, `Expected string in VecString, got ${typeof item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = bcs
+                    .vector(bcs.String)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case ValueType.VecU8:
+                if (value instanceof Uint8Array) {
+                    serializedValue = bcs
+                        .vector(bcs.U8)
+                        .serialize(Array.from(value))
+                        .toBytes();
+                }
+                else if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (!isValidU8(item)) {
+                            W_ERROR(WErrors.InvalidParam, `Expected valid U8 in VecU8, got ${item}`);
+                            return new Uint8Array(0);
+                        }
+                    }
+                    serializedValue = bcs
+                        .vector(bcs.U8)
+                        .serialize(value)
+                        .toBytes();
+                }
+                else {
+                    W_ERROR(WErrors.InvalidParam, `Expected Uint8Array or array for ValueType.VecU8, got ${typeof value}`);
+                    return new Uint8Array(0);
+                }
+                break;
+            case ValueType.VecU16:
+                if (!Array.isArray(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU16, got ${typeof value}`);
+                    return new Uint8Array(0);
+                }
+                for (const item of value) {
+                    if (!isValidU16(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U16 in VecU16, got ${item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = bcs
+                    .vector(bcs.U16)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case ValueType.VecU32:
+                if (!Array.isArray(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU32, got ${typeof value}`);
+                    return new Uint8Array(0);
+                }
+                for (const item of value) {
+                    if (!isValidU32(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U32 in VecU32, got ${item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = bcs
+                    .vector(bcs.U32)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case ValueType.VecU64:
+                if (!Array.isArray(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU64, got ${typeof value}`);
+                    return new Uint8Array(0);
+                }
+                for (const item of value) {
+                    if (!isValidU64(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U64 in VecU64, got ${item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                const vecU64Values = value.map(toU64Value);
+                serializedValue = bcs
+                    .vector(bcs.U64)
+                    .serialize(vecU64Values)
+                    .toBytes();
+                break;
+            case ValueType.VecU128:
+                if (!Array.isArray(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU128, got ${typeof value}`);
+                    return new Uint8Array(0);
+                }
+                for (const item of value) {
+                    if (!isValidU128(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U128 in VecU128, got ${item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                const vecU128Values = value.map(toU128Value);
+                serializedValue = bcs
+                    .vector(bcs.U128)
+                    .serialize(vecU128Values)
+                    .toBytes();
+                break;
+            case ValueType.VecU256:
+                if (!Array.isArray(value)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected array for ValueType.VecU256, got ${typeof value}`);
+                    return new Uint8Array(0);
+                }
+                for (const item of value) {
+                    if (!isValidU256(item)) {
+                        W_ERROR(WErrors.InvalidParam, `Expected valid U256 in VecU256, got ${item}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                const vecU256Values = value.map(toU256Value);
+                serializedValue = bcs
+                    .vector(bcs.U256)
+                    .serialize(vecU256Values)
+                    .toBytes();
+                break;
+            case ValueType.VecVecU8:
+                if (!Array.isArray(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))) {
+                        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 (!isValidU8(subItem)) {
+                                W_ERROR(WErrors.InvalidParam, `Expected valid U8 in VecVecU8, got ${subItem}`);
+                                return new Uint8Array(0);
+                            }
+                        }
+                    }
+                }
+                // 将 Uint8Array 转换为数组
+                const vecVecU8 = value.map((item) => item instanceof Uint8Array ? Array.from(item) : item);
+                serializedValue = bcs
+                    .vector(bcs.vector(bcs.U8))
+                    .serialize(vecVecU8)
+                    .toBytes();
+                break;
+            case ValueType.Value:
+                // Value 类型是递归的，包含一个 ValueContainer
+                // 第一个字节是内部的 ValueType，后续字节是 BCS 序列化的值
+                const container = value;
+                if (!container ||
+                    typeof container !== "object" ||
+                    !("valueType" in container) ||
+                    !("value" in container)) {
+                    W_ERROR(WErrors.InvalidParam, `Expected ValueContainer for ValueType.Value, got ${JSON.stringify(value)}`);
+                    return new Uint8Array(0);
+                }
+                // 验证内部的 valueType 是否有效
+                if (!isValidValueType(container.valueType)) {
+                    W_ERROR(WErrors.InvalidParam, `Invalid inner ValueType in ValueContainer: ${container.valueType}`);
+                    return new Uint8Array(0);
+                }
+                // 递归序列化内部值
+                serializedValue = await valueToBcsBytes(container.valueType, container.value);
+                break;
+            default:
+                W_ERROR(WErrors.InvalidParam, `Unsupported ValueType: ${valueType}`);
                 return new Uint8Array(0);
-              }
-            }
-          }
-        }
-        const vecVecU8 = value.map(
-          (item) => item instanceof Uint8Array ? Array.from(item) : item
-        );
-        serializedValue = bcs.vector(bcs.vector(bcs.U8)).serialize(vecVecU8).toBytes();
-        break;
-      case ValueType.Value:
-        const container = value;
-        if (!container || typeof container !== "object" || !("valueType" in container) || !("value" in container)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Expected ValueContainer for ValueType.Value, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
         }
-        if (!isValidValueType(container.valueType)) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `Invalid inner ValueType in ValueContainer: ${container.valueType}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = await valueToBcsBytes(
-          container.valueType,
-          container.value
-        );
-        break;
-      default:
-        W_ERROR(
-          WErrors.InvalidParam,
-          `Unsupported ValueType: ${valueType}`
-        );
+        // 合并结果
+        const finalResult = new Uint8Array(result.length + serializedValue.length);
+        finalResult.set(result, 0);
+        finalResult.set(serializedValue, 1);
+        return finalResult;
+    }
+    catch (error) {
+        W_ERROR(WErrors.InvalidParam, `BCS serialization failed: ${error.message}`);
         return new Uint8Array(0);
     }
-    const finalResult = new Uint8Array(
-      result.length + serializedValue.length
-    );
-    finalResult.set(result, 0);
-    finalResult.set(serializedValue, 1);
-    return finalResult;
-  } catch (error) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `BCS serialization failed: ${error.message}`
-    );
-    return new Uint8Array(0);
-  }
 };
-const bcsBytesToValue = (bytes, valueType) => {
-  if (bytes.length === 0) {
-    W_ERROR(WErrors.InvalidParam, "Empty bytes array");
-    return void 0;
-  }
-  const actualValueType = valueType ?? bytes[0];
-  if (!isValidValueType(actualValueType)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Invalid ValueType in bytes: ${actualValueType}`
-    );
-    return void 0;
-  }
-  if (bytes.length < 2) {
-    return void 0;
-  }
-  const dataBytes = bytes.slice(1);
-  try {
-    switch (actualValueType) {
-      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 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:
-        W_ERROR(
-          WErrors.InvalidParam,
-          `Unsupported ValueType for deserialization: ${actualValueType}`
-        );
-        return void 0;
+// 类型安全的反序列化函数
+export const bcsBytesToValue = (bytes, valueType) => {
+    if (bytes.length === 0) {
+        W_ERROR(WErrors.InvalidParam, "Empty bytes array");
+        return undefined;
+    }
+    // 获取 ValueType
+    const actualValueType = valueType ?? bytes[0];
+    // 验证 ValueType
+    if (!isValidValueType(actualValueType)) {
+        W_ERROR(WErrors.InvalidParam, `Invalid ValueType in bytes: ${actualValueType}`);
+        return undefined;
+    }
+    if (bytes.length < 2) {
+        return undefined;
+    }
+    // 获取 BCS 序列化的数据部分
+    const dataBytes = bytes.slice(1);
+    try {
+        switch (actualValueType) {
+            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 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:
+                W_ERROR(WErrors.InvalidParam, `Unsupported ValueType for deserialization: ${actualValueType}`);
+                return undefined;
+        }
+    }
+    catch (error) {
+        W_ERROR(WErrors.InvalidParam, `BCS deserialization failed: ${error.message}`);
+        return undefined;
     }
-  } catch (error) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `BCS deserialization failed: ${error.message}`
-    );
-    return void 0;
-  }
 };
-const parseObjectType = (chain_type, header = "payment::Payment") => {
-  header += "<";
-  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
-      );
-      return r;
+export const parseObjectType = (chain_type, header = "payment::Payment") => {
+    header += "<";
+    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);
+            return r;
+        }
     }
-  }
-  return void 0;
+    return undefined;
 };
-const parseTypeParameter = (type) => {
-  if (!type || !type.startsWith(PackageAddress)) {
-    return void 0;
-  }
-  const openIndex = type.indexOf("<");
-  const closeIndex = type.lastIndexOf(">");
-  if (openIndex === -1 || closeIndex === -1 || openIndex >= closeIndex) {
-    return void 0;
-  }
-  return type.slice(openIndex + 1, closeIndex);
+export const parseTypeParameter = (type) => {
+    if (!type || !type.startsWith(PackageAddress)) {
+        return undefined;
+    }
+    const openIndex = type.indexOf("<");
+    const closeIndex = type.lastIndexOf(">");
+    if (openIndex === -1 || closeIndex === -1 || openIndex >= closeIndex) {
+        return undefined;
+    }
+    return type.slice(openIndex + 1, closeIndex);
 };
-const extractCoinType = (type) => {
-  if (!type || !type.startsWith(PackageAddress)) {
-    return void 0;
-  }
-  const escapedPackageAddress = PackageAddress.replace(
-    /[.*+?^${}()|[\]\\]/g,
-    "\\$&"
-  );
-  const coinPattern = new RegExp(
-    `${escapedPackageAddress}::[^:]+::[^<]+<${escapedPackageAddress}::coin::Coin<([^>]+)>>`
-  );
-  const match = type.match(coinPattern);
-  if (match && match[1]) {
-    return match[1];
-  }
-  return void 0;
+export const extractCoinType = (type) => {
+    if (!type || !type.startsWith(PackageAddress)) {
+        return undefined;
+    }
+    // Match the pattern: PackageAddress::{}::{}<PackageAddress::coin::Coin<{}>>
+    const escapedPackageAddress = PackageAddress.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const coinPattern = new RegExp(`${escapedPackageAddress}::[^:]+::[^<]+<${escapedPackageAddress}::coin::Coin<([^>]+)>>`);
+    const match = type.match(coinPattern);
+    if (match && match[1]) {
+        return match[1];
+    }
+    return undefined;
 };
-async function owner_receive(tx, object, permission, param, caller_type, fnBuilder, passport) {
-  validObjects([object, permission, passport]);
-  if (caller_type && !IsValidArgType(caller_type)) {
-    W_ERROR(
-      WErrors.IsValidArgType,
-      `caller_type ${caller_type} is invalid`
-    );
-  }
-  if (Array.isArray(param)) {
-    for (const item of param) {
-      if (!item.type || !IsValidArgType(item.type)) {
-        W_ERROR(WErrors.IsValidArgType, `type ${item.type} is invalid`);
-      }
-      if (passport) {
-        const r = await LocalMark.Instance().get_address(item.id);
-        if (!r) {
-          W_ERROR(
-            WErrors.IsValidArgType,
-            `Received ${item.id} is invalid`
-          );
-        }
-        tx.moveCall({
-          target: fnBuilder("owner_receive_object_with_passport"),
-          arguments: [
-            toTxObject(tx, object),
-            toTxObject(tx, permission),
-            toTxObject(tx, passport),
-            toTxObject(tx, r)
-          ],
-          typeArguments: caller_type ? [caller_type, item.type] : [item.type]
-        });
-      } else {
-        const r = await LocalMark.Instance().get_address(item.id);
-        if (!r) {
-          W_ERROR(
-            WErrors.IsValidArgType,
-            `Received ${item.id} is invalid`
-          );
+export async function owner_receive(tx, object, // MachineObject | DemandObject | ServiceObject ...
+permission, param, caller_type, fnBuilder, // machineFn | demandFn
+passport) {
+    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 || !IsValidArgType(item.type)) {
+                W_ERROR(WErrors.IsValidArgType, `type ${item.type} is invalid`);
+            }
+            if (passport) {
+                const r = await LocalMark.Instance().get_address(item.id);
+                if (!r) {
+                    W_ERROR(WErrors.IsValidArgType, `Received ${item.id} is invalid`);
+                }
+                tx.moveCall({
+                    target: fnBuilder("owner_receive_object_with_passport"),
+                    arguments: [
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, passport),
+                        toTxObject(tx, r),
+                    ],
+                    typeArguments: caller_type
+                        ? [caller_type, item.type]
+                        : [item.type],
+                });
+            }
+            else {
+                const r = await LocalMark.Instance().get_address(item.id);
+                if (!r) {
+                    W_ERROR(WErrors.IsValidArgType, `Received ${item.id} is invalid`);
+                }
+                tx.moveCall({
+                    target: fnBuilder("owner_receive_object"),
+                    arguments: [
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, r),
+                    ],
+                    typeArguments: caller_type
+                        ? [caller_type, item.type]
+                        : [item.type],
+                });
+            }
         }
-        tx.moveCall({
-          target: fnBuilder("owner_receive_object"),
-          arguments: [
-            toTxObject(tx, object),
-            toTxObject(tx, permission),
-            toTxObject(tx, r)
-          ],
-          typeArguments: caller_type ? [caller_type, item.type] : [item.type]
-        });
-      }
     }
-  } else {
-    const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
-    if (!match) {
-      W_ERROR(
-        WErrors.IsValidArgType,
-        `Invalid CoinWrapper type: ${param.token_type}`
-      );
+    // 处理ReceivedBalance类型
+    else {
+        const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
+        if (!match) {
+            W_ERROR(WErrors.IsValidArgType, `Invalid CoinWrapper type: ${param.token_type}`);
+        }
+        const t = match[1];
+        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([
+                LocalMark.Instance().get_address(item.id),
+                LocalMark.Instance().get_address(item.payment),
+            ]);
+            if (!r || !p) {
+                W_ERROR(WErrors.IsValidArgType, `Received ${item.id} or Payment ${item.payment} is invalid`);
+            }
+            if (passport) {
+                tx.moveCall({
+                    target: fnBuilder("owner_receive_with_passport"),
+                    arguments: [
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, passport),
+                        toTxObject(tx, r),
+                        toTxObject(tx, p),
+                    ],
+                    typeArguments: caller_type ? [caller_type, t] : [t],
+                });
+            }
+            else {
+                tx.moveCall({
+                    target: fnBuilder("owner_receive"),
+                    arguments: [
+                        toTxObject(tx, object),
+                        toTxObject(tx, permission),
+                        toTxObject(tx, r),
+                        toTxObject(tx, p),
+                    ],
+                    typeArguments: caller_type ? [caller_type, t] : [t],
+                });
+            }
+        }
     }
-    const t = match[1];
-    if (!IsValidArgType(t)) {
-      W_ERROR(WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+}
+export function permission_set(tx, object, // MachineObject | DemandObject
+old_permission, new_permission, caller_type, fnBuilder) {
+    validObjects([object, old_permission, new_permission]);
+    if (caller_type && !IsValidArgType(caller_type)) {
+        W_ERROR(WErrors.IsValidArgType, `caller_type ${caller_type} is invalid`);
     }
-    for (const item of param.received) {
-      const [r, p] = await Promise.all([
-        LocalMark.Instance().get_address(item.id),
-        LocalMark.Instance().get_address(item.payment)
-      ]);
-      if (!r || !p) {
-        W_ERROR(
-          WErrors.IsValidArgType,
-          `Received ${item.id} or Payment ${item.payment} is invalid`
-        );
-      }
-      if (passport) {
-        tx.moveCall({
-          target: fnBuilder("owner_receive_with_passport"),
-          arguments: [
-            toTxObject(tx, object),
-            toTxObject(tx, permission),
-            toTxObject(tx, passport),
-            toTxObject(tx, r),
-            toTxObject(tx, p)
-          ],
-          typeArguments: caller_type ? [caller_type, t] : [t]
-        });
-      } else {
-        tx.moveCall({
-          target: fnBuilder("owner_receive"),
-          arguments: [
+    tx.moveCall({
+        target: fnBuilder("permission_set"),
+        arguments: [
             toTxObject(tx, object),
-            toTxObject(tx, permission),
-            toTxObject(tx, r),
-            toTxObject(tx, p)
-          ],
-          typeArguments: caller_type ? [caller_type, t] : [t]
-        });
-      }
-    }
-  }
+            toTxObject(tx, old_permission),
+            toTxObject(tx, new_permission),
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
+        ],
+        typeArguments: caller_type ? [caller_type] : [],
+    });
 }
-function permission_set(tx, object, old_permission, new_permission, caller_type, fnBuilder) {
-  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: [
-      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) => {
-  objects.forEach((item, index) => {
-    if (typeof item === "string" && item != null) {
-      if (!isValidAddress(item)) {
-        W_ERROR(WErrors.IsValidAddress, `Address is invalid: ${item}`);
-      }
-    } else {
-      if (!allowNull && !item) {
-        W_ERROR(
-          WErrors.IsValidAddress,
-          `Address is required at index ${index} in objects ${objects}`
-        );
-      }
-    }
-  });
-};
-const uint2address = (value) => {
-  return normalizeWowAddress(value.toString(16));
+export const validObjects = (objects, allowNull = true) => {
+    objects.forEach((item, index) => {
+        if (typeof item === "string" && item != null) {
+            if (!isValidAddress(item)) {
+                W_ERROR(WErrors.IsValidAddress, `Address is invalid: ${item}`);
+            }
+        }
+        else {
+            if (!allowNull && !item) {
+                W_ERROR(WErrors.IsValidAddress, `Address is required at index ${index} in objects ${objects}`);
+            }
+        }
+    });
 };
-const parseRecipient = (whoData) => {
-  if (!whoData || !whoData.variant) {
-    W_ERROR(
-      WErrors.ParseObjectContentFailed,
-      `Invalid who data: ${JSON.stringify(whoData)}`
-    );
-  }
-  if (whoData.variant === "GuardIdentifier" && whoData.fields) {
-    return {
-      GuardIdentifier: Number(whoData.fields.pos0)
-    };
-  } else if (whoData.variant === "Entity" && whoData.fields) {
-    return {
-      Entity: {
-        name_or_address: whoData.fields.pos0
-      }
-    };
-  } else if (whoData.variant === "Signer") {
-    return {
-      Signer: null
-    };
-  } else {
-    W_ERROR(
-      WErrors.ParseObjectContentFailed,
-      `Invalid who variant: ${whoData.variant}`
-    );
-  }
+export const uint2address = (value) => {
+    return normalizeWowAddress(value.toString(16));
 };
-export {
-  bcsBytesToValue,
-  extractCoinType,
-  isValidValueContainer,
-  owner_receive,
-  parseObjectType,
-  parseRecipient,
-  parseTypeParameter,
-  permission_set,
-  uint2address,
-  validObjects,
-  valueToBcsBytes
+// 将 whoData 转换为 Recipient 类型
+export const parseRecipient = (whoData) => {
+    if (!whoData || !whoData.variant) {
+        W_ERROR(WErrors.ParseObjectContentFailed, `Invalid who data: ${JSON.stringify(whoData)}`);
+    }
+    if (whoData.variant === "GuardIdentifier" && whoData.fields) {
+        return {
+            GuardIdentifier: Number(whoData.fields.pos0),
+        };
+    }
+    else if (whoData.variant === "Entity" && whoData.fields) {
+        return {
+            Entity: {
+                name_or_address: whoData.fields.pos0,
+            },
+        };
+    }
+    else if (whoData.variant === "Signer") {
+        return {
+            Signer: null,
+        };
+    }
+    else {
+        W_ERROR(WErrors.ParseObjectContentFailed, `Invalid who variant: ${whoData.variant}`);
+    }
 };
+//# sourceMappingURL=util.js.map