wowok 1.8.2 → 2.1.9

package/dist/cjs/w/util.js

@@ -0,0 +1,715 @@
+"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");
+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);
+    }
+  }
+  return value;
+};
+const toU128Value = (value) => {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return BigInt(value);
+  }
+  return BigInt(value);
+};
+const toU256Value = (value) => {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "string") {
+    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);
+            }
+          }
+          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}`
+                );
+                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}`
+        );
+        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);
+  }
+};
+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;
+    }
+  } catch (error) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `BCS deserialization failed: ${error.message}`
+    );
+    return void 0;
+  }
+};
+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;
+    }
+  }
+  return void 0;
+};
+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);
+};
+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]
+        });
+      }
+    }
+  } 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}`
+      );
+    }
+    const t = match[1];
+    if (!(0, import_common.IsValidArgType)(t)) {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidArgType, `Invalid CoinWrapper type: ${t}`);
+    }
+    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]
+        });
+      }
+    }
+  }
+}
+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] : []
+  });
+}
+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}`
+        );
+      }
+    }
+  });
+};
+const uint2address = (value) => {
+  return (0, import_sui_types.normalizeWowAddress)(value.toString(16));
+};
+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}`
+    );
+  }
+};