wowok 2.1.10 → 2.1.13

package/dist/cjs/w/util.js

@@ -1,715 +1,629 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var util_exports = {};
-__export(util_exports, {
-  bcsBytesToValue: () => bcsBytesToValue,
-  extractCoinType: () => extractCoinType,
-  isValidValueContainer: () => isValidValueContainer,
-  owner_receive: () => owner_receive,
-  parseObjectType: () => parseObjectType,
-  parseRecipient: () => parseRecipient,
-  parseTypeParameter: () => parseTypeParameter,
-  permission_set: () => permission_set,
-  uint2address: () => uint2address,
-  validObjects: () => validObjects,
-  valueToBcsBytes: () => valueToBcsBytes
-});
-module.exports = __toCommonJS(util_exports);
-var import_bcs = require("../bcs/index.js");
-var import_common = require("./common.js");
-var import_exception = require("./exception.js");
-var import_local = require("./local/index.js");
-var import_common2 = require("./common.js");
-var import_sui_types = require("../utils/sui-types.js");
-var import_local2 = require("./local/local.js");
-var import_local3 = require("./local/local.js");
+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");
+// 验证 ValueContainer 的函数
 const isValidValueContainer = (container) => {
-  try {
-    valueToBcsBytes(container.valueType, container.value);
-    return true;
-  } catch {
-    return false;
-  }
+    try {
+        // 通过尝试序列化来验证容器的有效性
+        (0, exports.valueToBcsBytes)(container.valueType, container.value);
+        return true;
+    }
+    catch {
+        return false;
+    }
 };
+exports.isValidValueContainer = isValidValueContainer;
 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 (!(0, import_common.isValidValueType)(valueType)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Invalid ValueType: ${valueType}`);
-    return new Uint8Array(0);
-  }
-  const result = new Uint8Array(1);
-  result[0] = valueType;
-  try {
-    let serializedValue;
-    switch (valueType) {
-      case import_common.ValueType.Bool:
-        serializedValue = import_bcs.bcs.Bool.serialize(
-          value
-        ).toBytes();
-        break;
-      case import_common.ValueType.Address: {
-        let addressValue;
-        let errorDetails = "";
-        if (typeof value === "string") {
-          addressValue = await (0, import_local.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 (0, import_local.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) {
-          (0, import_exception.W_ERROR)(
-            import_exception.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 = import_bcs.bcs.Address.serialize(addressValue).toBytes();
-        break;
-      }
-      case import_common.ValueType.String:
-        serializedValue = import_bcs.bcs.String.serialize(
-          value
-        ).toBytes();
-        break;
-      case import_common.ValueType.U8:
-        if (!(0, import_common.isValidU8)(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected valid U8 for ValueType.U8, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = import_bcs.bcs.U8.serialize(value).toBytes();
-        break;
-      case import_common.ValueType.U16:
-        if (!(0, import_common.isValidU16)(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected valid U16 for ValueType.U16, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = import_bcs.bcs.U16.serialize(value).toBytes();
-        break;
-      case import_common.ValueType.U32:
-        if (!(0, import_common.isValidU32)(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected valid U32 for ValueType.U32, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = import_bcs.bcs.U32.serialize(value).toBytes();
-        break;
-      case import_common.ValueType.U64:
-        if (!(0, import_common.isValidU64)(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected valid U64 for ValueType.U64, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = import_bcs.bcs.U64.serialize(
-          toU64Value(value)
-        ).toBytes();
-        break;
-      case import_common.ValueType.U128:
-        if (!(0, import_common.isValidU128)(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected valid U128 for ValueType.U128, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = import_bcs.bcs.U128.serialize(
-          toU128Value(value)
-        ).toBytes();
-        break;
-      case import_common.ValueType.U256:
-        if (!(0, import_common.isValidU256)(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected valid U256 for ValueType.U256, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = import_bcs.bcs.U256.serialize(
-          toU256Value(value)
-        ).toBytes();
-        break;
-      case import_common.ValueType.VecBool:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecBool, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (typeof item !== "boolean") {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected boolean in VecBool, got ${typeof item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.Bool).serialize(value).toBytes();
-        break;
-      case import_common.ValueType.VecAddress:
-        const r = await (0, import_local.GetManyAccountOrMark_Address)(
-          value
-        );
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.Address).serialize(r).toBytes();
-        break;
-      case import_common.ValueType.VecString:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecString, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (typeof item !== "string") {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected string in VecString, got ${typeof item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.String).serialize(value).toBytes();
-        break;
-      case import_common.ValueType.VecU8:
-        if (value instanceof Uint8Array) {
-          serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U8).serialize(Array.from(value)).toBytes();
-        } else if (Array.isArray(value)) {
-          for (const item of value) {
-            if (!(0, import_common.isValidU8)(item)) {
-              (0, import_exception.W_ERROR)(
-                import_exception.WErrors.InvalidParam,
-                `Expected valid U8 in VecU8, got ${item}`
-              );
-              return new Uint8Array(0);
+    // 验证 ValueType
+    if (!(0, common_js_1.isValidValueType)(valueType)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Invalid ValueType: ${valueType}`);
+        return new Uint8Array(0);
+    }
+    // 创建结果数组，第一个字节为 ValueType
+    const result = new Uint8Array(1);
+    result[0] = valueType;
+    try {
+        let serializedValue;
+        switch (valueType) {
+            case common_js_1.ValueType.Bool:
+                serializedValue = index_js_1.bcs.Bool.serialize(value).toBytes();
+                break;
+            case common_js_1.ValueType.Address: {
+                let addressValue;
+                let errorDetails = "";
+                // 尝试不同的方式获取地址
+                if (typeof value === "string") {
+                    // 如果是字符串，直接尝试解析
+                    addressValue = await (0, index_js_2.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 (0, index_js_2.GetAccountOrMark_Address)(accountOrMarkAddr);
+                    errorDetails = `AccountOrMark_Address: ${JSON.stringify(value)}`;
+                }
+                else {
+                    // 其他类型
+                    addressValue = undefined;
+                    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.`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.bcs.Address.serialize(addressValue).toBytes();
+                break;
             }
-          }
-          serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U8).serialize(value).toBytes();
-        } else {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected Uint8Array or array for ValueType.VecU8, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        break;
-      case import_common.ValueType.VecU16:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecU16, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!(0, import_common.isValidU16)(item)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected valid U16 in VecU16, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U16).serialize(value).toBytes();
-        break;
-      case import_common.ValueType.VecU32:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecU32, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!(0, import_common.isValidU32)(item)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected valid U32 in VecU32, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U32).serialize(value).toBytes();
-        break;
-      case import_common.ValueType.VecU64:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecU64, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!(0, import_common.isValidU64)(item)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected valid U64 in VecU64, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        const vecU64Values = value.map(toU64Value);
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U64).serialize(vecU64Values).toBytes();
-        break;
-      case import_common.ValueType.VecU128:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecU128, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!(0, import_common.isValidU128)(item)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected valid U128 in VecU128, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        const vecU128Values = value.map(toU128Value);
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U128).serialize(vecU128Values).toBytes();
-        break;
-      case import_common.ValueType.VecU256:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected array for ValueType.VecU256, got ${typeof value}`
-          );
-          return new Uint8Array(0);
-        }
-        for (const item of value) {
-          if (!(0, import_common.isValidU256)(item)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              `Expected valid U256 in VecU256, got ${item}`
-            );
-            return new Uint8Array(0);
-          }
-        }
-        const vecU256Values = value.map(toU256Value);
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.U256).serialize(vecU256Values).toBytes();
-        break;
-      case import_common.ValueType.VecVecU8:
-        if (!Array.isArray(value)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.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, import_exception.W_ERROR)(
-              import_exception.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, import_common.isValidU8)(subItem)) {
-                (0, import_exception.W_ERROR)(
-                  import_exception.WErrors.InvalidParam,
-                  `Expected valid U8 in VecVecU8, got ${subItem}`
-                );
+            case common_js_1.ValueType.String:
+                serializedValue = index_js_1.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)}`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.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)}`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.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)}`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.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)}`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.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)}`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.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)}`);
+                    return new Uint8Array(0);
+                }
+                serializedValue = index_js_1.bcs.U256.serialize(toU256Value(value)).toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.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)
+                    .serialize(r)
+                    .toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.bcs.String)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case common_js_1.ValueType.VecU8:
+                if (value instanceof Uint8Array) {
+                    serializedValue = index_js_1.bcs
+                        .vector(index_js_1.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}`);
+                            return new Uint8Array(0);
+                        }
+                    }
+                    serializedValue = index_js_1.bcs
+                        .vector(index_js_1.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}`);
+                    return new Uint8Array(0);
+                }
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.bcs.U16)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.bcs.U32)
+                    .serialize(value)
+                    .toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                const vecU64Values = value.map(toU64Value);
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.bcs.U64)
+                    .serialize(vecU64Values)
+                    .toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                const vecU128Values = value.map(toU128Value);
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.bcs.U128)
+                    .serialize(vecU128Values)
+                    .toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        return new Uint8Array(0);
+                    }
+                }
+                const vecU256Values = value.map(toU256Value);
+                serializedValue = index_js_1.bcs
+                    .vector(index_js_1.bcs.U256)
+                    .serialize(vecU256Values)
+                    .toBytes();
+                break;
+            case common_js_1.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}`);
+                    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}`);
+                        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}`);
+                                return new Uint8Array(0);
+                            }
+                        }
+                    }
+                }
+                // 将 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))
+                    .serialize(vecVecU8)
+                    .toBytes();
+                break;
+            case common_js_1.ValueType.Value:
+                // Value 类型是递归的，包含一个 ValueContainer
+                // 第一个字节是内部的 ValueType，后续字节是 BCS 序列化的值
+                const container = value;
+                if (!container ||
+                    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)}`);
+                    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}`);
+                    return new Uint8Array(0);
+                }
+                // 递归序列化内部值
+                serializedValue = await (0, exports.valueToBcsBytes)(container.valueType, container.value);
+                break;
+            default:
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Unsupported ValueType: ${valueType}`);
                 return new Uint8Array(0);
-              }
-            }
-          }
-        }
-        const vecVecU8 = value.map(
-          (item) => item instanceof Uint8Array ? Array.from(item) : item
-        );
-        serializedValue = import_bcs.bcs.vector(import_bcs.bcs.vector(import_bcs.bcs.U8)).serialize(vecVecU8).toBytes();
-        break;
-      case import_common.ValueType.Value:
-        const container = value;
-        if (!container || typeof container !== "object" || !("valueType" in container) || !("value" in container)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Expected ValueContainer for ValueType.Value, got ${JSON.stringify(value)}`
-          );
-          return new Uint8Array(0);
         }
-        if (!(0, import_common.isValidValueType)(container.valueType)) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            `Invalid inner ValueType in ValueContainer: ${container.valueType}`
-          );
-          return new Uint8Array(0);
-        }
-        serializedValue = await valueToBcsBytes(
-          container.valueType,
-          container.value
-        );
-        break;
-      default:
-        (0, import_exception.W_ERROR)(
-          import_exception.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) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.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) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `BCS serialization failed: ${error.message}`
-    );
-    return new Uint8Array(0);
-  }
 };
+exports.valueToBcsBytes = valueToBcsBytes;
+// 类型安全的反序列化函数
 const bcsBytesToValue = (bytes, valueType) => {
-  if (bytes.length === 0) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "Empty bytes array");
-    return void 0;
-  }
-  const actualValueType = valueType ?? bytes[0];
-  if (!(0, import_common.isValidValueType)(actualValueType)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.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 import_common.ValueType.Bool:
-        return import_bcs.bcs.Bool.parse(dataBytes);
-      case import_common.ValueType.Address:
-        return import_bcs.bcs.Address.parse(dataBytes);
-      case import_common.ValueType.String:
-        return import_bcs.bcs.String.parse(dataBytes);
-      case import_common.ValueType.U8:
-        return import_bcs.bcs.U8.parse(dataBytes);
-      case import_common.ValueType.U16:
-        return import_bcs.bcs.U16.parse(dataBytes);
-      case import_common.ValueType.U32:
-        return import_bcs.bcs.U32.parse(dataBytes);
-      case import_common.ValueType.U64:
-        return import_bcs.bcs.U64.parse(dataBytes);
-      case import_common.ValueType.U128:
-        return import_bcs.bcs.U128.parse(dataBytes);
-      case import_common.ValueType.U256:
-        return import_bcs.bcs.U256.parse(dataBytes);
-      case import_common.ValueType.VecBool:
-        return import_bcs.bcs.vector(import_bcs.bcs.Bool).parse(dataBytes);
-      case import_common.ValueType.VecAddress:
-        const addresses = import_bcs.bcs.vector(import_bcs.bcs.Address).parse(dataBytes);
-        return {
-          entities: addresses.map((addr) => ({
-            name_or_address: addr
-          }))
-        };
-      case import_common.ValueType.VecString:
-        return import_bcs.bcs.vector(import_bcs.bcs.String).parse(dataBytes);
-      case import_common.ValueType.VecU8:
-        return import_bcs.bcs.vector(import_bcs.bcs.U8).parse(dataBytes);
-      case import_common.ValueType.VecU16:
-        return import_bcs.bcs.vector(import_bcs.bcs.U16).parse(dataBytes);
-      case import_common.ValueType.VecU32:
-        return import_bcs.bcs.vector(import_bcs.bcs.U32).parse(dataBytes);
-      case import_common.ValueType.VecU64:
-        return import_bcs.bcs.vector(import_bcs.bcs.U64).parse(dataBytes);
-      case import_common.ValueType.VecU128:
-        return import_bcs.bcs.vector(import_bcs.bcs.U128).parse(dataBytes);
-      case import_common.ValueType.VecU256:
-        return import_bcs.bcs.vector(import_bcs.bcs.U256).parse(dataBytes);
-      case import_common.ValueType.VecVecU8:
-        return import_bcs.bcs.vector(import_bcs.bcs.vector(import_bcs.bcs.U8)).parse(dataBytes);
-      default:
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          `Unsupported ValueType for deserialization: ${actualValueType}`
-        );
-        return void 0;
+    if (bytes.length === 0) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.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}`);
+        return undefined;
+    }
+    if (bytes.length < 2) {
+        return undefined;
+    }
+    // 获取 BCS 序列化的数据部分
+    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);
+                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);
+            default:
+                (0, exception_js_1.W_ERROR)(exception_js_1.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}`);
+        return undefined;
     }
-  } catch (error) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `BCS deserialization failed: ${error.message}`
-    );
-    return void 0;
-  }
 };
+exports.bcsBytesToValue = bcsBytesToValue;
 const parseObjectType = (chain_type, header = "payment::Payment") => {
-  header += "<";
-  if (chain_type && (0, import_common.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;
+    header += "<";
+    if (chain_type && (0, common_js_1.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;
 };
+exports.parseObjectType = parseObjectType;
 const parseTypeParameter = (type) => {
-  if (!type || !type.startsWith(import_common.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);
+    if (!type || !type.startsWith(common_js_1.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);
 };
+exports.parseTypeParameter = parseTypeParameter;
 const extractCoinType = (type) => {
-  if (!type || !type.startsWith(import_common.PackageAddress)) {
-    return void 0;
-  }
-  const escapedPackageAddress = import_common.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;
-};
-async function owner_receive(tx, object, permission, param, caller_type, fnBuilder, passport) {
-  validObjects([object, permission, passport]);
-  if (caller_type && !(0, import_common.IsValidArgType)(caller_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidArgType,
-      `caller_type ${caller_type} is invalid`
-    );
-  }
-  if (Array.isArray(param)) {
-    for (const item of param) {
-      if (!item.type || !(0, import_common.IsValidArgType)(item.type)) {
-        (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidArgType, `type ${item.type} is invalid`);
-      }
-      if (passport) {
-        const r = await import_local2.LocalMark.Instance().get_address(item.id);
-        if (!r) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.IsValidArgType,
-            `Received ${item.id} is invalid`
-          );
-        }
-        tx.moveCall({
-          target: fnBuilder("owner_receive_object_with_passport"),
-          arguments: [
-            (0, import_common2.toTxObject)(tx, object),
-            (0, import_common2.toTxObject)(tx, permission),
-            (0, import_common2.toTxObject)(tx, passport),
-            (0, import_common2.toTxObject)(tx, r)
-          ],
-          typeArguments: caller_type ? [caller_type, item.type] : [item.type]
-        });
-      } else {
-        const r = await import_local2.LocalMark.Instance().get_address(item.id);
-        if (!r) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.IsValidArgType,
-            `Received ${item.id} is invalid`
-          );
-        }
-        tx.moveCall({
-          target: fnBuilder("owner_receive_object"),
-          arguments: [
-            (0, import_common2.toTxObject)(tx, object),
-            (0, import_common2.toTxObject)(tx, permission),
-            (0, import_common2.toTxObject)(tx, r)
-          ],
-          typeArguments: caller_type ? [caller_type, item.type] : [item.type]
-        });
-      }
+    if (!type || !type.startsWith(common_js_1.PackageAddress)) {
+        return undefined;
     }
-  } else {
-    const match = param.token_type.match(/CoinWrapper<([^>]+)>/);
-    if (!match) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.IsValidArgType,
-        `Invalid CoinWrapper type: ${param.token_type}`
-      );
+    // Match the pattern: PackageAddress::{}::{}<PackageAddress::coin::Coin<{}>>
+    const escapedPackageAddress = common_js_1.PackageAddress.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const coinPattern = new RegExp(`${escapedPackageAddress}::[^:]+::[^<]+<${escapedPackageAddress}::coin::Coin<([^>]+)>>`);
+    const match = type.match(coinPattern);
+    if (match && match[1]) {
+        return match[1];
     }
-    const t = match[1];
-    if (!(0, import_common.IsValidArgType)(t)) {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+    return undefined;
+};
+exports.extractCoinType = extractCoinType;
+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`);
+    }
+    // 处理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 (passport) {
+                const r = await local_js_1.LocalMark.Instance().get_address(item.id);
+                if (!r) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.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),
+                    ],
+                    typeArguments: caller_type
+                        ? [caller_type, item.type]
+                        : [item.type],
+                });
+            }
+            else {
+                const r = await local_js_1.LocalMark.Instance().get_address(item.id);
+                if (!r) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.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),
+                    ],
+                    typeArguments: caller_type
+                        ? [caller_type, item.type]
+                        : [item.type],
+                });
+            }
+        }
     }
-    for (const item of param.received) {
-      const [r, p] = await Promise.all([
-        import_local2.LocalMark.Instance().get_address(item.id),
-        import_local2.LocalMark.Instance().get_address(item.payment)
-      ]);
-      if (!r || !p) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidArgType,
-          `Received ${item.id} or Payment ${item.payment} is invalid`
-        );
-      }
-      if (passport) {
-        tx.moveCall({
-          target: fnBuilder("owner_receive_with_passport"),
-          arguments: [
-            (0, import_common2.toTxObject)(tx, object),
-            (0, import_common2.toTxObject)(tx, permission),
-            (0, import_common2.toTxObject)(tx, passport),
-            (0, import_common2.toTxObject)(tx, r),
-            (0, import_common2.toTxObject)(tx, p)
-          ],
-          typeArguments: caller_type ? [caller_type, t] : [t]
-        });
-      } else {
-        tx.moveCall({
-          target: fnBuilder("owner_receive"),
-          arguments: [
-            (0, import_common2.toTxObject)(tx, object),
-            (0, import_common2.toTxObject)(tx, permission),
-            (0, import_common2.toTxObject)(tx, r),
-            (0, import_common2.toTxObject)(tx, p)
-          ],
-          typeArguments: caller_type ? [caller_type, t] : [t]
-        });
-      }
+    // 处理ReceivedBalance类型
+    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}`);
+        }
+        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}`);
+        }
+        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),
+            ]);
+            if (!r || !p) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.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),
+                    ],
+                    typeArguments: caller_type ? [caller_type, t] : [t],
+                });
+            }
+            else {
+                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),
+                    ],
+                    typeArguments: caller_type ? [caller_type, t] : [t],
+                });
+            }
+        }
     }
-  }
 }
-function permission_set(tx, object, old_permission, new_permission, caller_type, fnBuilder) {
-  validObjects([object, old_permission, new_permission]);
-  if (caller_type && !(0, import_common.IsValidArgType)(caller_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.IsValidArgType,
-      `caller_type ${caller_type} is invalid`
-    );
-  }
-  tx.moveCall({
-    target: fnBuilder("permission_set"),
-    arguments: [
-      (0, import_common2.toTxObject)(tx, object),
-      (0, import_common2.toTxObject)(tx, old_permission),
-      (0, import_common2.toTxObject)(tx, new_permission),
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: caller_type ? [caller_type] : []
-  });
+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`);
+    }
+    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),
+            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 (!(0, import_local3.isValidAddress)(item)) {
-        (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidAddress, `Address is invalid: ${item}`);
-      }
-    } else {
-      if (!allowNull && !item) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidAddress,
-          `Address is required at index ${index} in objects ${objects}`
-        );
-      }
-    }
-  });
+    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}`);
+            }
+        }
+        else {
+            if (!allowNull && !item) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `Address is required at index ${index} in objects ${objects}`);
+            }
+        }
+    });
 };
+exports.validObjects = validObjects;
 const uint2address = (value) => {
-  return (0, import_sui_types.normalizeWowAddress)(value.toString(16));
+    return (0, sui_types_js_1.normalizeWowAddress)(value.toString(16));
 };
+exports.uint2address = uint2address;
+// 将 whoData 转换为 Recipient 类型
 const parseRecipient = (whoData) => {
-  if (!whoData || !whoData.variant) {
-    (0, import_exception.W_ERROR)(
-      import_exception.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 {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.ParseObjectContentFailed,
-      `Invalid who variant: ${whoData.variant}`
-    );
-  }
+    if (!whoData || !whoData.variant) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.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 {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.ParseObjectContentFailed, `Invalid who variant: ${whoData.variant}`);
+    }
 };
+exports.parseRecipient = parseRecipient;
+//# sourceMappingURL=util.js.map