wowok 1.8.3 → 2.1.9

package/dist/cjs/transactions/resolve.js

@@ -0,0 +1,103 @@
+"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 resolve_exports = {};
+__export(resolve_exports, {
+  getClient: () => getClient,
+  needsTransactionResolution: () => needsTransactionResolution,
+  resolveTransactionPlugin: () => resolveTransactionPlugin
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_Inputs = require("./Inputs.js");
+var import_bcs = require("../bcs/index.js");
+var import_json_rpc_resolver = require("../jsonRpc/json-rpc-resolver.js");
+function needsTransactionResolution(data, options) {
+  if (data.inputs.some((input) => {
+    return input.UnresolvedObject || input.UnresolvedPure;
+  })) {
+    return true;
+  }
+  if (!options.onlyTransactionKind) {
+    if (!data.gasConfig.price || !data.gasConfig.budget || !data.gasConfig.payment) {
+      return true;
+    }
+  }
+  return false;
+}
+async function resolveTransactionPlugin(transactionData, options, next) {
+  normalizeRawArguments(transactionData);
+  if (!needsTransactionResolution(transactionData, options)) {
+    await validate(transactionData);
+    return next();
+  }
+  const client = getClient(options);
+  const plugin = client.core?.resolveTransactionPlugin() ?? (0, import_json_rpc_resolver.jsonRpcClientResolveTransactionPlugin)(client);
+  return plugin(transactionData, options, async () => {
+    await validate(transactionData);
+    await next();
+  });
+}
+function validate(transactionData) {
+  transactionData.inputs.forEach((input, index) => {
+    if (input.$kind !== "Object" && input.$kind !== "Pure") {
+      throw new Error(
+        `Input at index ${index} has not been resolved.  Expected a Pure or Object input, but found ${JSON.stringify(
+          input
+        )}`
+      );
+    }
+  });
+}
+function getClient(options) {
+  if (!options.client) {
+    throw new Error(
+      `No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`
+    );
+  }
+  return options.client;
+}
+function normalizeRawArguments(transactionData) {
+  for (const command of transactionData.commands) {
+    switch (command.$kind) {
+      case "SplitCoins":
+        command.SplitCoins.amounts.forEach((amount) => {
+          normalizeRawArgument(amount, import_bcs.bcs.U64, transactionData);
+        });
+        break;
+      case "TransferObjects":
+        normalizeRawArgument(
+          command.TransferObjects.address,
+          import_bcs.bcs.Address,
+          transactionData
+        );
+        break;
+    }
+  }
+}
+function normalizeRawArgument(arg, schema, transactionData) {
+  if (arg.$kind !== "Input") {
+    return;
+  }
+  const input = transactionData.inputs[arg.Input];
+  if (input.$kind !== "UnresolvedPure") {
+    return;
+  }
+  transactionData.inputs[arg.Input] = import_Inputs.Inputs.Pure(
+    schema.serialize(input.UnresolvedPure.value)
+  );
+}

package/dist/cjs/transactions/serializer.d.ts

@@ -0,0 +1,7 @@
+import type { BcsType } from "@mysten/bcs";
+import type { SuiMoveNormalizedType } from "../client/index.js";
+import type { OpenMoveTypeSignature, OpenMoveTypeSignatureBody } from "./data/internal.js";
+export declare function isTxContext(param: OpenMoveTypeSignature): boolean;
+export declare function getPureBcsSchema(typeSignature: OpenMoveTypeSignatureBody): BcsType<any> | null;
+export declare function normalizedTypeToMoveTypeSignature(type: SuiMoveNormalizedType): OpenMoveTypeSignature;
+export declare function pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature: OpenMoveTypeSignatureBody): BcsType<any>;

package/dist/cjs/transactions/serializer.js

@@ -0,0 +1,189 @@
+"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 serializer_exports = {};
+__export(serializer_exports, {
+  getPureBcsSchema: () => getPureBcsSchema,
+  isTxContext: () => isTxContext,
+  normalizedTypeToMoveTypeSignature: () => normalizedTypeToMoveTypeSignature,
+  pureBcsSchemaFromOpenMoveTypeSignatureBody: () => pureBcsSchemaFromOpenMoveTypeSignatureBody
+});
+module.exports = __toCommonJS(serializer_exports);
+var import_bcs = require("../bcs/index.js");
+var import_utils = require("../utils/index.js");
+var import_sui_types = require("../utils/sui-types.js");
+const OBJECT_MODULE_NAME = "object";
+const ID_STRUCT_NAME = "ID";
+const STD_ASCII_MODULE_NAME = "ascii";
+const STD_ASCII_STRUCT_NAME = "String";
+const STD_UTF8_MODULE_NAME = "string";
+const STD_UTF8_STRUCT_NAME = "String";
+const STD_OPTION_MODULE_NAME = "option";
+const STD_OPTION_STRUCT_NAME = "Option";
+function isTxContext(param) {
+  const struct = typeof param.body === "object" && "datatype" in param.body ? param.body.datatype : null;
+  return !!struct && (0, import_sui_types.normalizeWowAddress)(struct.package) === (0, import_sui_types.normalizeWowAddress)("0x2") && struct.module === "tx_context" && struct.type === "TxContext";
+}
+function getPureBcsSchema(typeSignature) {
+  if (typeof typeSignature === "string") {
+    switch (typeSignature) {
+      case "address":
+        return import_bcs.bcs.Address;
+      case "bool":
+        return import_bcs.bcs.Bool;
+      case "u8":
+        return import_bcs.bcs.U8;
+      case "u16":
+        return import_bcs.bcs.U16;
+      case "u32":
+        return import_bcs.bcs.U32;
+      case "u64":
+        return import_bcs.bcs.U64;
+      case "u128":
+        return import_bcs.bcs.U128;
+      case "u256":
+        return import_bcs.bcs.U256;
+      default:
+        throw new Error(`Unknown type signature ${typeSignature}`);
+    }
+  }
+  if ("vector" in typeSignature) {
+    if (typeSignature.vector === "u8") {
+      return import_bcs.bcs.byteVector().transform({
+        input: (val) => typeof val === "string" ? new TextEncoder().encode(val) : val,
+        output: (val) => val
+      });
+    }
+    const type = getPureBcsSchema(typeSignature.vector);
+    return type ? import_bcs.bcs.vector(type) : null;
+  }
+  if ("datatype" in typeSignature) {
+    const pkg = (0, import_sui_types.normalizeWowAddress)(typeSignature.datatype.package);
+    if (pkg === (0, import_sui_types.normalizeWowAddress)(import_utils.MOVE_STDLIB_ADDRESS)) {
+      if (typeSignature.datatype.module === STD_ASCII_MODULE_NAME && typeSignature.datatype.type === STD_ASCII_STRUCT_NAME) {
+        return import_bcs.bcs.String;
+      }
+      if (typeSignature.datatype.module === STD_UTF8_MODULE_NAME && typeSignature.datatype.type === STD_UTF8_STRUCT_NAME) {
+        return import_bcs.bcs.String;
+      }
+      if (typeSignature.datatype.module === STD_OPTION_MODULE_NAME && typeSignature.datatype.type === STD_OPTION_STRUCT_NAME) {
+        const type = getPureBcsSchema(
+          typeSignature.datatype.typeParameters[0]
+        );
+        return type ? import_bcs.bcs.vector(type) : null;
+      }
+    }
+    if (pkg === (0, import_sui_types.normalizeWowAddress)(import_utils.WOW_FRAMEWORK_ADDRESS) && typeSignature.datatype.module === OBJECT_MODULE_NAME && typeSignature.datatype.type === ID_STRUCT_NAME) {
+      return import_bcs.bcs.Address;
+    }
+  }
+  return null;
+}
+function normalizedTypeToMoveTypeSignature(type) {
+  if (typeof type === "object" && "Reference" in type) {
+    return {
+      ref: "&",
+      body: normalizedTypeToMoveTypeSignatureBody(type.Reference)
+    };
+  }
+  if (typeof type === "object" && "MutableReference" in type) {
+    return {
+      ref: "&mut",
+      body: normalizedTypeToMoveTypeSignatureBody(type.MutableReference)
+    };
+  }
+  return {
+    ref: null,
+    body: normalizedTypeToMoveTypeSignatureBody(type)
+  };
+}
+function normalizedTypeToMoveTypeSignatureBody(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "Address":
+        return "address";
+      case "Bool":
+        return "bool";
+      case "U8":
+        return "u8";
+      case "U16":
+        return "u16";
+      case "U32":
+        return "u32";
+      case "U64":
+        return "u64";
+      case "U128":
+        return "u128";
+      case "U256":
+        return "u256";
+      default:
+        throw new Error(`Unexpected type ${type}`);
+    }
+  }
+  if ("Vector" in type) {
+    return { vector: normalizedTypeToMoveTypeSignatureBody(type.Vector) };
+  }
+  if ("Struct" in type) {
+    return {
+      datatype: {
+        package: type.Struct.address,
+        module: type.Struct.module,
+        type: type.Struct.name,
+        typeParameters: type.Struct.typeArguments.map(
+          normalizedTypeToMoveTypeSignatureBody
+        )
+      }
+    };
+  }
+  if ("TypeParameter" in type) {
+    return { typeParameter: type.TypeParameter };
+  }
+  throw new Error(`Unexpected type ${JSON.stringify(type)}`);
+}
+function pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature) {
+  if (typeof typeSignature === "string") {
+    switch (typeSignature) {
+      case "address":
+        return import_bcs.bcs.Address;
+      case "bool":
+        return import_bcs.bcs.Bool;
+      case "u8":
+        return import_bcs.bcs.U8;
+      case "u16":
+        return import_bcs.bcs.U16;
+      case "u32":
+        return import_bcs.bcs.U32;
+      case "u64":
+        return import_bcs.bcs.U64;
+      case "u128":
+        return import_bcs.bcs.U128;
+      case "u256":
+        return import_bcs.bcs.U256;
+      default:
+        throw new Error(`Unknown type signature ${typeSignature}`);
+    }
+  }
+  if ("vector" in typeSignature) {
+    return import_bcs.bcs.vector(
+      pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature.vector)
+    );
+  }
+  throw new Error(
+    `Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`
+  );
+}

package/dist/cjs/transactions/utils.d.ts

@@ -0,0 +1,10 @@
+import type { SuiMoveNormalizedType } from "../client/index.js";
+import type { Argument, CallArg, Command } from "./data/internal.js";
+export declare function extractMutableReference(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedType | undefined;
+export declare function extractReference(normalizedType: SuiMoveNormalizedType): SuiMoveNormalizedType | undefined;
+export declare function extractStructTag(normalizedType: SuiMoveNormalizedType): Extract<SuiMoveNormalizedType, {
+    Struct: unknown;
+}> | undefined;
+export declare function getIdFromCallArg(arg: string | CallArg): string | undefined;
+export declare function isArgument(value: unknown): value is Argument;
+export declare function remapCommandArguments(command: Command, inputMapping: Map<number, number>, commandMapping: Map<number, number>): void;

package/dist/cjs/transactions/utils.js

@@ -0,0 +1,143 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  extractMutableReference: () => extractMutableReference,
+  extractReference: () => extractReference,
+  extractStructTag: () => extractStructTag,
+  getIdFromCallArg: () => getIdFromCallArg,
+  isArgument: () => isArgument,
+  remapCommandArguments: () => remapCommandArguments
+});
+module.exports = __toCommonJS(utils_exports);
+var import_valibot = require("valibot");
+var import_sui_types = require("../utils/sui-types.js");
+var import_internal = require("./data/internal.js");
+function extractMutableReference(normalizedType) {
+  return typeof normalizedType === "object" && "MutableReference" in normalizedType ? normalizedType.MutableReference : void 0;
+}
+function extractReference(normalizedType) {
+  return typeof normalizedType === "object" && "Reference" in normalizedType ? normalizedType.Reference : void 0;
+}
+function extractStructTag(normalizedType) {
+  if (typeof normalizedType === "object" && "Struct" in normalizedType) {
+    return normalizedType;
+  }
+  const ref = extractReference(normalizedType);
+  const mutRef = extractMutableReference(normalizedType);
+  if (typeof ref === "object" && "Struct" in ref) {
+    return ref;
+  }
+  if (typeof mutRef === "object" && "Struct" in mutRef) {
+    return mutRef;
+  }
+  return void 0;
+}
+function getIdFromCallArg(arg) {
+  if (typeof arg === "string") {
+    return (0, import_sui_types.normalizeWowAddress)(arg);
+  }
+  if (arg.Object) {
+    if (arg.Object.ImmOrOwnedObject) {
+      return (0, import_sui_types.normalizeWowAddress)(arg.Object.ImmOrOwnedObject.objectId);
+    }
+    if (arg.Object.Receiving) {
+      return (0, import_sui_types.normalizeWowAddress)(arg.Object.Receiving.objectId);
+    }
+    return (0, import_sui_types.normalizeWowAddress)(arg.Object.SharedObject.objectId);
+  }
+  if (arg.UnresolvedObject) {
+    return (0, import_sui_types.normalizeWowAddress)(arg.UnresolvedObject.objectId);
+  }
+  return void 0;
+}
+function isArgument(value) {
+  return (0, import_valibot.is)(import_internal.ArgumentSchema, value);
+}
+function remapCommandArguments(command, inputMapping, commandMapping) {
+  const remapArg = (arg) => {
+    switch (arg.$kind) {
+      case "Input": {
+        const newInputIndex = inputMapping.get(arg.Input);
+        if (newInputIndex === void 0) {
+          throw new Error(
+            `Input ${arg.Input} not found in input mapping`
+          );
+        }
+        return { ...arg, Input: newInputIndex };
+      }
+      case "Result": {
+        const newCommandIndex = commandMapping.get(arg.Result);
+        if (newCommandIndex !== void 0) {
+          return { ...arg, Result: newCommandIndex };
+        }
+        return arg;
+      }
+      case "NestedResult": {
+        const newCommandIndex = commandMapping.get(arg.NestedResult[0]);
+        if (newCommandIndex !== void 0) {
+          return {
+            ...arg,
+            NestedResult: [newCommandIndex, arg.NestedResult[1]]
+          };
+        }
+        return arg;
+      }
+      default:
+        return arg;
+    }
+  };
+  switch (command.$kind) {
+    case "MoveCall":
+      command.MoveCall.arguments = command.MoveCall.arguments.map(remapArg);
+      break;
+    case "TransferObjects":
+      command.TransferObjects.objects = command.TransferObjects.objects.map(remapArg);
+      command.TransferObjects.address = remapArg(
+        command.TransferObjects.address
+      );
+      break;
+    case "SplitCoins":
+      command.SplitCoins.coin = remapArg(command.SplitCoins.coin);
+      command.SplitCoins.amounts = command.SplitCoins.amounts.map(remapArg);
+      break;
+    case "MergeCoins":
+      command.MergeCoins.destination = remapArg(
+        command.MergeCoins.destination
+      );
+      command.MergeCoins.sources = command.MergeCoins.sources.map(remapArg);
+      break;
+    case "MakeMoveVec":
+      command.MakeMoveVec.elements = command.MakeMoveVec.elements.map(remapArg);
+      break;
+    case "Upgrade":
+      command.Upgrade.ticket = remapArg(command.Upgrade.ticket);
+      break;
+    case "$Intent": {
+      const inputs = command.$Intent.inputs;
+      command.$Intent.inputs = {};
+      for (const [key, value] of Object.entries(inputs)) {
+        command.$Intent.inputs[key] = Array.isArray(value) ? value.map(remapArg) : remapArg(value);
+      }
+      break;
+    }
+    case "Publish":
+      break;
+  }
+}

package/dist/cjs/utils/constants.d.ts

@@ -0,0 +1,17 @@
+export declare const SUI_DECIMALS = 9;
+export declare const MIST_PER_SUI: bigint;
+export declare const SUI_FRAMEWORK_ADDRESS = "0x2";
+export declare const SUI_SYSTEM_ADDRESS = "0x3";
+export declare const SUI_SYSTEM_MODULE_NAME = "sui_system";
+export declare const SUI_TYPE_ARG = "0x2::sui::SUI";
+export declare const WOW_DECIMALS = 9;
+export declare const MIST_PER_WOW: bigint;
+export declare const WOW_FRAMEWORK_ADDRESS = "0x2";
+export declare const WOW_SYSTEM_ADDRESS = "0x3";
+export declare const WOW_ADDRESS = "0x4";
+export declare const WOW_CLOCK_OBJECT_ID: string;
+export declare const WOW_SYSTEM_MODULE_NAME = "wow_system";
+export declare const WOW_TYPE_ARG = "0x2::wow::WOW";
+export declare const WOW_SYSTEM_STATE_OBJECT_ID: string;
+export declare const WOW_RANDOM_OBJECT_ID: string;
+export declare const MOVE_STDLIB_ADDRESS = "0x1";

package/dist/cjs/utils/constants.js

@@ -0,0 +1,57 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  MIST_PER_SUI: () => MIST_PER_SUI,
+  MIST_PER_WOW: () => MIST_PER_WOW,
+  MOVE_STDLIB_ADDRESS: () => MOVE_STDLIB_ADDRESS,
+  SUI_DECIMALS: () => SUI_DECIMALS,
+  SUI_FRAMEWORK_ADDRESS: () => SUI_FRAMEWORK_ADDRESS,
+  SUI_SYSTEM_ADDRESS: () => SUI_SYSTEM_ADDRESS,
+  SUI_SYSTEM_MODULE_NAME: () => SUI_SYSTEM_MODULE_NAME,
+  SUI_TYPE_ARG: () => SUI_TYPE_ARG,
+  WOW_ADDRESS: () => WOW_ADDRESS,
+  WOW_CLOCK_OBJECT_ID: () => WOW_CLOCK_OBJECT_ID,
+  WOW_DECIMALS: () => WOW_DECIMALS,
+  WOW_FRAMEWORK_ADDRESS: () => WOW_FRAMEWORK_ADDRESS,
+  WOW_RANDOM_OBJECT_ID: () => WOW_RANDOM_OBJECT_ID,
+  WOW_SYSTEM_ADDRESS: () => WOW_SYSTEM_ADDRESS,
+  WOW_SYSTEM_MODULE_NAME: () => WOW_SYSTEM_MODULE_NAME,
+  WOW_SYSTEM_STATE_OBJECT_ID: () => WOW_SYSTEM_STATE_OBJECT_ID,
+  WOW_TYPE_ARG: () => WOW_TYPE_ARG
+});
+module.exports = __toCommonJS(constants_exports);
+var import_sui_types = require("./sui-types.js");
+const SUI_DECIMALS = 9;
+const MIST_PER_SUI = BigInt(1e9);
+const SUI_FRAMEWORK_ADDRESS = "0x2";
+const SUI_SYSTEM_ADDRESS = "0x3";
+const SUI_SYSTEM_MODULE_NAME = "sui_system";
+const SUI_TYPE_ARG = `${SUI_FRAMEWORK_ADDRESS}::sui::SUI`;
+const WOW_DECIMALS = 9;
+const MIST_PER_WOW = BigInt(1e9);
+const WOW_FRAMEWORK_ADDRESS = "0x2";
+const WOW_SYSTEM_ADDRESS = "0x3";
+const WOW_ADDRESS = "0x4";
+const WOW_CLOCK_OBJECT_ID = (0, import_sui_types.normalizeWowObjectId)("0x6");
+const WOW_SYSTEM_MODULE_NAME = "wow_system";
+const WOW_TYPE_ARG = `${WOW_FRAMEWORK_ADDRESS}::wow::WOW`;
+const WOW_SYSTEM_STATE_OBJECT_ID = (0, import_sui_types.normalizeWowObjectId)("0x5");
+const WOW_RANDOM_OBJECT_ID = (0, import_sui_types.normalizeWowObjectId)("0x8");
+const MOVE_STDLIB_ADDRESS = "0x1";

package/dist/cjs/utils/derived-objects.d.ts

@@ -0,0 +1,5 @@
+import type { TypeTag } from "../bcs/bcs.js";
+/**
+ * Derive the ID of an object that has been created through `derived_object`.
+ */
+export declare function deriveObjectID(parentId: string, typeTag: typeof TypeTag.$inferInput, key: Uint8Array): string;

package/dist/cjs/utils/derived-objects.js

@@ -0,0 +1,33 @@
+"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 derived_objects_exports = {};
+__export(derived_objects_exports, {
+  deriveObjectID: () => deriveObjectID
+});
+module.exports = __toCommonJS(derived_objects_exports);
+var import_type_tag_serializer = require("../bcs/type-tag-serializer.js");
+var import_dynamic_fields = require("./dynamic-fields.js");
+function deriveObjectID(parentId, typeTag, key) {
+  const typeTagStr = typeof typeTag === "string" ? typeTag : import_type_tag_serializer.TypeTagSerializer.tagToString(typeTag);
+  return (0, import_dynamic_fields.deriveDynamicFieldID)(
+    parentId,
+    `0x2::derived_object::DerivedObjectKey<${typeTagStr}>`,
+    key
+  );
+}

package/dist/cjs/utils/dynamic-fields.d.ts

@@ -0,0 +1,2 @@
+import type { TypeTag } from "../bcs/bcs.js";
+export declare function deriveDynamicFieldID(parentId: string, typeTag: typeof TypeTag.$inferInput, key: Uint8Array): string;

package/dist/cjs/utils/dynamic-fields.js

@@ -0,0 +1,40 @@
+"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 dynamic_fields_exports = {};
+__export(dynamic_fields_exports, {
+  deriveDynamicFieldID: () => deriveDynamicFieldID
+});
+module.exports = __toCommonJS(dynamic_fields_exports);
+var import_bcs = require("@mysten/bcs");
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_bcs2 = require("../bcs/index.js");
+function deriveDynamicFieldID(parentId, typeTag, key) {
+  const address = import_bcs2.bcs.Address.serialize(parentId).toBytes();
+  const tag = import_bcs2.bcs.TypeTag.serialize(typeTag).toBytes();
+  const keyLength = import_bcs2.bcs.u64().serialize(key.length).toBytes();
+  const hash = import_blake2b.blake2b.create({
+    dkLen: 32
+  });
+  hash.update(new Uint8Array([240]));
+  hash.update(address);
+  hash.update(keyLength);
+  hash.update(key);
+  hash.update(tag);
+  return `0x${(0, import_bcs.toHex)(hash.digest().slice(0, 32))}`;
+}

package/dist/cjs/utils/format.d.ts

@@ -0,0 +1,2 @@
+export declare function formatAddress(address: string): string;
+export declare function formatDigest(digest: string): string;

package/dist/cjs/utils/format.js

@@ -0,0 +1,35 @@
+"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 format_exports = {};
+__export(format_exports, {
+  formatAddress: () => formatAddress,
+  formatDigest: () => formatDigest
+});
+module.exports = __toCommonJS(format_exports);
+const ELLIPSIS = "\u2026";
+function formatAddress(address) {
+  if (address.length <= 6) {
+    return address;
+  }
+  const offset = address.startsWith("0x") ? 2 : 0;
+  return `0x${address.slice(offset, offset + 4)}${ELLIPSIS}${address.slice(-4)}`;
+}
+function formatDigest(digest) {
+  return `${digest.slice(0, 10)}${ELLIPSIS}`;
+}

package/dist/cjs/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { formatAddress, formatDigest } from "./format.js";
+export { isValidWowAddress, isValidWowObjectId, isValidTransactionDigest, normalizeStructTag, normalizeWowAddress, normalizeWowObjectId, parseStructTag, WOW_ADDRESS_LENGTH, } from "./sui-types.js";
+export { fromB64, toB64, fromHEX, toHex, toHEX, fromHex, fromBase64, toBase64, fromBase58, toBase58, } from "@mysten/bcs";
+export { WOW_DECIMALS, MIST_PER_WOW, MOVE_STDLIB_ADDRESS, WOW_FRAMEWORK_ADDRESS, WOW_SYSTEM_ADDRESS, WOW_CLOCK_OBJECT_ID, WOW_SYSTEM_MODULE_NAME, WOW_TYPE_ARG, WOW_SYSTEM_STATE_OBJECT_ID, WOW_RANDOM_OBJECT_ID, } from "./constants.js";
+export { isValidNamedPackage, isValidNamedType } from "./move-registry.js";
+export { deriveDynamicFieldID } from "./dynamic-fields.js";
+export { deriveObjectID } from "./derived-objects.js";
+export { normalizeTypeTag } from "../bcs/type-tag-serializer.js";