wowok 1.8.2 → 2.1.9

package/dist/esm/transactions/pure.d.ts

@@ -0,0 +1,20 @@
+import type { SerializedBcs } from "@mysten/bcs";
+import type { PureTypeName, ShapeFromPureTypeName, ValidPureTypeName } from "../bcs/pure.js";
+export declare function createPure<T>(makePure: (value: SerializedBcs<any, any> | Uint8Array) => T): {
+    <Type extends PureTypeName>(type: Type extends PureTypeName ? ValidPureTypeName<Type> : Type, value: ShapeFromPureTypeName<Type>): T;
+    (value: SerializedBcs<any, any> | Uint8Array): T;
+    u8(value: number): T;
+    u16(value: number): T;
+    u32(value: number): T;
+    u64(value: bigint | number | string): T;
+    u128(value: bigint | number | string): T;
+    u256(value: bigint | number | string): T;
+    bool(value: boolean): T;
+    string(value: string): T;
+    address(value: string): T;
+    id: (value: string) => T;
+    vector<Type extends PureTypeName>(type: Type extends PureTypeName ? ValidPureTypeName<Type> : Type, value: Iterable<ShapeFromPureTypeName<Type>> & {
+        length: number;
+    }): T;
+    option<Type extends PureTypeName>(type: Type extends PureTypeName ? ValidPureTypeName<Type> : Type, value: ShapeFromPureTypeName<Type> | null | undefined): T;
+};

package/dist/esm/transactions/pure.js

@@ -0,0 +1,44 @@
+import { isSerializedBcs } from "@mysten/bcs";
+import { bcs } from "../bcs/index.js";
+import { pureBcsSchemaFromTypeName } from "../bcs/pure.js";
+function createPure(makePure) {
+  function pure(typeOrSerializedValue, value) {
+    if (typeof typeOrSerializedValue === "string") {
+      return makePure(
+        pureBcsSchemaFromTypeName(typeOrSerializedValue).serialize(
+          value
+        )
+      );
+    }
+    if (typeOrSerializedValue instanceof Uint8Array || isSerializedBcs(typeOrSerializedValue)) {
+      return makePure(typeOrSerializedValue);
+    }
+    throw new Error(
+      "tx.pure must be called either a bcs type name, or a serialized bcs value"
+    );
+  }
+  pure.u8 = (value) => makePure(bcs.U8.serialize(value));
+  pure.u16 = (value) => makePure(bcs.U16.serialize(value));
+  pure.u32 = (value) => makePure(bcs.U32.serialize(value));
+  pure.u64 = (value) => makePure(bcs.U64.serialize(value));
+  pure.u128 = (value) => makePure(bcs.U128.serialize(value));
+  pure.u256 = (value) => makePure(bcs.U256.serialize(value));
+  pure.bool = (value) => makePure(bcs.Bool.serialize(value));
+  pure.string = (value) => makePure(bcs.String.serialize(value));
+  pure.address = (value) => makePure(bcs.Address.serialize(value));
+  pure.id = pure.address;
+  pure.vector = (type, value) => {
+    return makePure(
+      bcs.vector(pureBcsSchemaFromTypeName(type)).serialize(value)
+    );
+  };
+  pure.option = (type, value) => {
+    return makePure(
+      bcs.option(pureBcsSchemaFromTypeName(type)).serialize(value)
+    );
+  };
+  return pure;
+}
+export {
+  createPure
+};

package/dist/esm/transactions/resolve.d.ts

@@ -0,0 +1,13 @@
+import type { ClientWithCoreApi } from "../experimental/index.js";
+import type { TransactionDataBuilder } from "./TransactionData.js";
+export interface BuildTransactionOptions {
+    client?: ClientWithCoreApi;
+    onlyTransactionKind?: boolean;
+}
+export interface SerializeTransactionOptions extends BuildTransactionOptions {
+    supportedIntents?: string[];
+}
+export type TransactionPlugin = (transactionData: TransactionDataBuilder, options: BuildTransactionOptions, next: () => Promise<void>) => Promise<void>;
+export declare function needsTransactionResolution(data: TransactionDataBuilder, options: BuildTransactionOptions): boolean;
+export declare function resolveTransactionPlugin(transactionData: TransactionDataBuilder, options: BuildTransactionOptions, next: () => Promise<void>): Promise<void>;
+export declare function getClient(options: BuildTransactionOptions): ClientWithCoreApi;

package/dist/esm/transactions/resolve.js

@@ -0,0 +1,83 @@
+import { Inputs } from "./Inputs.js";
+import { bcs } from "../bcs/index.js";
+import { jsonRpcClientResolveTransactionPlugin } from "../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() ?? 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, bcs.U64, transactionData);
+        });
+        break;
+      case "TransferObjects":
+        normalizeRawArgument(
+          command.TransferObjects.address,
+          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] = Inputs.Pure(
+    schema.serialize(input.UnresolvedPure.value)
+  );
+}
+export {
+  getClient,
+  needsTransactionResolution,
+  resolveTransactionPlugin
+};

package/dist/esm/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/esm/transactions/serializer.js

@@ -0,0 +1,169 @@
+import { bcs } from "../bcs/index.js";
+import { MOVE_STDLIB_ADDRESS, WOW_FRAMEWORK_ADDRESS } from "../utils/index.js";
+import { normalizeWowAddress } from "../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 && normalizeWowAddress(struct.package) === normalizeWowAddress("0x2") && struct.module === "tx_context" && struct.type === "TxContext";
+}
+function getPureBcsSchema(typeSignature) {
+  if (typeof typeSignature === "string") {
+    switch (typeSignature) {
+      case "address":
+        return bcs.Address;
+      case "bool":
+        return bcs.Bool;
+      case "u8":
+        return bcs.U8;
+      case "u16":
+        return bcs.U16;
+      case "u32":
+        return bcs.U32;
+      case "u64":
+        return bcs.U64;
+      case "u128":
+        return bcs.U128;
+      case "u256":
+        return bcs.U256;
+      default:
+        throw new Error(`Unknown type signature ${typeSignature}`);
+    }
+  }
+  if ("vector" in typeSignature) {
+    if (typeSignature.vector === "u8") {
+      return bcs.byteVector().transform({
+        input: (val) => typeof val === "string" ? new TextEncoder().encode(val) : val,
+        output: (val) => val
+      });
+    }
+    const type = getPureBcsSchema(typeSignature.vector);
+    return type ? bcs.vector(type) : null;
+  }
+  if ("datatype" in typeSignature) {
+    const pkg = normalizeWowAddress(typeSignature.datatype.package);
+    if (pkg === normalizeWowAddress(MOVE_STDLIB_ADDRESS)) {
+      if (typeSignature.datatype.module === STD_ASCII_MODULE_NAME && typeSignature.datatype.type === STD_ASCII_STRUCT_NAME) {
+        return bcs.String;
+      }
+      if (typeSignature.datatype.module === STD_UTF8_MODULE_NAME && typeSignature.datatype.type === STD_UTF8_STRUCT_NAME) {
+        return 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 ? bcs.vector(type) : null;
+      }
+    }
+    if (pkg === normalizeWowAddress(WOW_FRAMEWORK_ADDRESS) && typeSignature.datatype.module === OBJECT_MODULE_NAME && typeSignature.datatype.type === ID_STRUCT_NAME) {
+      return 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 bcs.Address;
+      case "bool":
+        return bcs.Bool;
+      case "u8":
+        return bcs.U8;
+      case "u16":
+        return bcs.U16;
+      case "u32":
+        return bcs.U32;
+      case "u64":
+        return bcs.U64;
+      case "u128":
+        return bcs.U128;
+      case "u256":
+        return bcs.U256;
+      default:
+        throw new Error(`Unknown type signature ${typeSignature}`);
+    }
+  }
+  if ("vector" in typeSignature) {
+    return bcs.vector(
+      pureBcsSchemaFromOpenMoveTypeSignatureBody(typeSignature.vector)
+    );
+  }
+  throw new Error(
+    `Expected pure typeSignature, but got ${JSON.stringify(typeSignature)}`
+  );
+}
+export {
+  getPureBcsSchema,
+  isTxContext,
+  normalizedTypeToMoveTypeSignature,
+  pureBcsSchemaFromOpenMoveTypeSignatureBody
+};

package/dist/esm/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/esm/transactions/utils.js

@@ -0,0 +1,123 @@
+import { is } from "valibot";
+import { normalizeWowAddress } from "../utils/sui-types.js";
+import { ArgumentSchema } from "./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 normalizeWowAddress(arg);
+  }
+  if (arg.Object) {
+    if (arg.Object.ImmOrOwnedObject) {
+      return normalizeWowAddress(arg.Object.ImmOrOwnedObject.objectId);
+    }
+    if (arg.Object.Receiving) {
+      return normalizeWowAddress(arg.Object.Receiving.objectId);
+    }
+    return normalizeWowAddress(arg.Object.SharedObject.objectId);
+  }
+  if (arg.UnresolvedObject) {
+    return normalizeWowAddress(arg.UnresolvedObject.objectId);
+  }
+  return void 0;
+}
+function isArgument(value) {
+  return is(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;
+  }
+}
+export {
+  extractMutableReference,
+  extractReference,
+  extractStructTag,
+  getIdFromCallArg,
+  isArgument,
+  remapCommandArguments
+};

package/dist/esm/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/esm/utils/constants.js

@@ -0,0 +1,37 @@
+import { normalizeWowObjectId } from "./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 = normalizeWowObjectId("0x6");
+const WOW_SYSTEM_MODULE_NAME = "wow_system";
+const WOW_TYPE_ARG = `${WOW_FRAMEWORK_ADDRESS}::wow::WOW`;
+const WOW_SYSTEM_STATE_OBJECT_ID = normalizeWowObjectId("0x5");
+const WOW_RANDOM_OBJECT_ID = normalizeWowObjectId("0x8");
+const MOVE_STDLIB_ADDRESS = "0x1";
+export {
+  MIST_PER_SUI,
+  MIST_PER_WOW,
+  MOVE_STDLIB_ADDRESS,
+  SUI_DECIMALS,
+  SUI_FRAMEWORK_ADDRESS,
+  SUI_SYSTEM_ADDRESS,
+  SUI_SYSTEM_MODULE_NAME,
+  SUI_TYPE_ARG,
+  WOW_ADDRESS,
+  WOW_CLOCK_OBJECT_ID,
+  WOW_DECIMALS,
+  WOW_FRAMEWORK_ADDRESS,
+  WOW_RANDOM_OBJECT_ID,
+  WOW_SYSTEM_ADDRESS,
+  WOW_SYSTEM_MODULE_NAME,
+  WOW_SYSTEM_STATE_OBJECT_ID,
+  WOW_TYPE_ARG
+};

package/dist/esm/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/esm/utils/derived-objects.js

@@ -0,0 +1,13 @@
+import { TypeTagSerializer } from "../bcs/type-tag-serializer.js";
+import { deriveDynamicFieldID } from "./dynamic-fields.js";
+function deriveObjectID(parentId, typeTag, key) {
+  const typeTagStr = typeof typeTag === "string" ? typeTag : TypeTagSerializer.tagToString(typeTag);
+  return deriveDynamicFieldID(
+    parentId,
+    `0x2::derived_object::DerivedObjectKey<${typeTagStr}>`,
+    key
+  );
+}
+export {
+  deriveObjectID
+};

package/dist/esm/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/esm/utils/dynamic-fields.js

@@ -0,0 +1,20 @@
+import { toHex } from "@mysten/bcs";
+import { blake2b } from "@noble/hashes/blake2b";
+import { bcs } from "../bcs/index.js";
+function deriveDynamicFieldID(parentId, typeTag, key) {
+  const address = bcs.Address.serialize(parentId).toBytes();
+  const tag = bcs.TypeTag.serialize(typeTag).toBytes();
+  const keyLength = bcs.u64().serialize(key.length).toBytes();
+  const hash = blake2b.create({
+    dkLen: 32
+  });
+  hash.update(new Uint8Array([240]));
+  hash.update(address);
+  hash.update(keyLength);
+  hash.update(key);
+  hash.update(tag);
+  return `0x${toHex(hash.digest().slice(0, 32))}`;
+}
+export {
+  deriveDynamicFieldID
+};

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

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

package/dist/esm/utils/format.js

@@ -0,0 +1,15 @@
+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}`;
+}
+export {
+  formatAddress,
+  formatDigest
+};

package/dist/esm/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";