@aptos-labs/ts-sdk 1.29.1 → 1.30.0

package/dist/esm/bcs/deserializer.d.mts

@@ -9,41 +9,77 @@ import '../types/generated/types.mjs';
  * deserialize a byte buffer into a type T.
  * It is not intended to be implemented or extended, because Typescript has no support
  * for static methods in interfaces.
+ *
+ * @template T - The type that this will deserialize into.
  */
 interface Deserializable<T> {
+    /**
+     * Deserializes the buffered bytes into an instance of the specified class type.
+     * This function provides an alternative syntax for deserialization, allowing users to call
+     * `deserializer.deserialize(MyClass)` instead of `MyClass.deserialize(deserializer)`.
+     *
+     * @param deserializer - The deserializer instance with the buffered bytes.
+     * @returns The deserialized value of class type T.
+     * @example
+     * ```typescript
+     * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
+     * const value = deserializer.deserialize(MyClass); // where MyClass has a `deserialize` function
+     * // value is now an instance of MyClass
+     * // equivalent to `const value = MyClass.deserialize(deserializer)`
+     * ```
+     */
     deserialize(deserializer: Deserializer): T;
 }
+/**
+ * A class that provides methods for deserializing various data types from a byte buffer.
+ * It supports deserialization of primitive types, strings, and complex objects using a BCS (Binary Common Serialization) layout.
+ */
 declare class Deserializer {
     private buffer;
     private offset;
+    /**
+     * Creates a new instance of the class with a copy of the provided data buffer.
+     * This prevents outside mutation of the buffer.
+     *
+     * @param data - The data to be copied into the internal buffer as a Uint8Array.
+     */
     constructor(data: Uint8Array);
+    /**
+     * Reads a specified number of bytes from the buffer and advances the offset.
+     *
+     * @param length - The number of bytes to read from the buffer.
+     * @throws Throws an error if the read operation exceeds the buffer's length.
+     */
     private read;
     /**
      * Returns the number of bytes remaining in the buffer.
      *
-     * Useful to tell if there's more data to be read.
+     * This information is useful to determine if there's more data to be read.
+     *
+     * @returns The number of bytes remaining in the buffer.
      */
     remaining(): number;
     /**
-     * Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
-     * and then reads "l" bytes of content. Decodes the byte array into a string.
+     * Deserializes a UTF-8 encoded string from a byte array. It first reads the length of the string in bytes,
+     * followed by the actual byte content, and decodes it into a string.
      *
      * BCS layout for "string": string_length | string_content
      * where string_length is a u32 integer encoded as a uleb128 integer, equal to the number of bytes in string_content.
      *
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
      * assert(deserializer.deserializeStr() === "1234abcd");
      * ```
      */
     deserializeStr(): string;
     /**
-     * Deserializes a an optional string.
+     * Deserializes an optional string.
      *
-     * BCS layout for Optional<String>: 0 if none, else 1 | string_length | string_content
+     * The BCS layout for Optional<String> is 0 if none, else 1 followed by the string length and string content.
+     * @returns The deserialized string if it exists, otherwise undefined.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x00]));
      * assert(deserializer.deserializeOptionStr() === undefined);
      * const deserializer = new Deserializer(new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
@@ -52,9 +88,9 @@ declare class Deserializer {
      */
     deserializeOptionStr(): string | undefined;
     /**
-     * Deserializes a an optional deserializable class.
+     * Deserializes an optional deserializable class.
      *
-     * BCS layout for Optional<T>: 0 if none, else 1 | bcs representation of class
+     * BCS layout for Optional<T>: 0 if none, else 1 | BCS representation of class.
      *
      * @example
      * const deserializer = new Deserializer(new Uint8Array([1, 2, 3]));
@@ -67,50 +103,59 @@ declare class Deserializer {
      *
      * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
      *
-     * @returns the deserialized value of class type T
+     * @returns The deserialized value of class type T or undefined if no value exists.
      */
     deserializeOption<T>(cls: Deserializable<T>): T | undefined;
     /**
      * Deserializes an array of bytes.
      *
-     * BCS layout for "bytes": bytes_length | bytes
-     * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
+     * The BCS layout for "bytes" consists of a bytes_length followed by the bytes themselves, where bytes_length is a u32 integer
+     * encoded as a uleb128 integer, indicating the length of the bytes array.
+     *
+     * @returns {Uint8Array} The deserialized array of bytes.
      */
     deserializeBytes(): Uint8Array;
     /**
-     * Deserializes an array of bytes. The number of bytes to read is already known.
+     * Deserializes an array of bytes of a specified length.
      *
+     * @param len - The number of bytes to read from the source.
      */
     deserializeFixedBytes(len: number): Uint8Array;
     /**
-     * Deserializes a boolean value.
+     * Deserializes a boolean value from a byte stream.
+     *
+     * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
+     * An error is thrown if the byte value is not valid.
      *
-     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+     * @returns The deserialized boolean value.
+     * @throws Throws an error if the boolean value is invalid.
      */
     deserializeBool(): boolean;
     /**
-     * Deserializes a uint8 number.
+     * Deserializes a uint8 number from the binary data.
      *
      * BCS layout for "uint8": One byte. Binary format in little-endian representation.
+     *
+     * @returns {number} The deserialized uint8 number.
      */
     deserializeU8(): Uint8;
     /**
-     * Deserializes a uint16 number.
+     * Deserializes a uint16 number from a binary format in little-endian representation.
      *
-     * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
+     * BCS layout for "uint16": Two bytes.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
      * assert(deserializer.deserializeU16() === 4660);
      * ```
      */
     deserializeU16(): Uint16;
     /**
-     * Deserializes a uint32 number.
+     * Deserializes a uint32 number from a binary format in little-endian representation.
      *
-     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * BCS layout for "uint32": Four bytes.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
      * assert(deserializer.deserializeU32() === 305419896);
      * ```
@@ -119,30 +164,36 @@ declare class Deserializer {
     /**
      * Deserializes a uint64 number.
      *
-     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * This function combines two 32-bit values to return a 64-bit unsigned integer in little-endian representation.
      * @example
-     * ```ts
+     * ```typescript
      * const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
      * assert(deserializer.deserializeU64() === 1311768467750121216);
      * ```
      */
     deserializeU64(): Uint64;
     /**
-     * Deserializes a uint128 number.
+     * Deserializes a uint128 number from its binary representation.
+     * This function combines two 64-bit values to return a single uint128 value in little-endian format.
      *
-     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     * @returns {BigInt} The deserialized uint128 number.
      */
     deserializeU128(): Uint128;
     /**
-     * Deserializes a uint256 number.
+     * Deserializes a uint256 number from its binary representation.
+     *
+     * The BCS layout for "uint256" consists of thirty-two bytes in little-endian format.
      *
-     * BCS layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
+     * @returns {BigInt} The deserialized uint256 number.
      */
     deserializeU256(): Uint256;
     /**
      * Deserializes a uleb128 encoded uint32 number.
      *
-     * BCS use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     * This function is used for interpreting lengths of variable-length sequences and tags of enum values in BCS encoding.
+     *
+     * @throws {Error} Throws an error if the parsed value exceeds the maximum uint32 number.
+     * @returns {number} The deserialized uint32 value.
      */
     deserializeUleb128AsU32(): Uint32;
     /**
@@ -160,10 +211,10 @@ declare class Deserializer {
      */
     deserialize<T>(cls: Deserializable<T>): T;
     /**
-     * Deserializes an array of BCS Deserializable values given an existing Deserializer
-     * instance with a loaded byte buffer.
+     * Deserializes an array of BCS Deserializable values given an existing Deserializer instance with a loaded byte buffer.
      *
      * @param cls The BCS-deserializable class to deserialize the buffered bytes into.
+     * @returns An array of deserialized values of type T.
      * @example
      * // serialize a vector of addresses
      * const addresses = new Array<AccountAddress>(
@@ -180,7 +231,6 @@ declare class Deserializer {
      * const deserializer = new Deserializer(serializedBytes);
      * const deserializedAddresses = deserializer.deserializeVector(AccountAddress);
      * // deserializedAddresses is now an array of AccountAddress instances
-     * @returns an array of deserialized values of type T
      */
     deserializeVector<T>(cls: Deserializable<T>): Array<T>;
 }

package/dist/esm/bcs/deserializer.mjs

@@ -1,2 +1,2 @@
-import{a}from"../chunk-KEYAPEAX.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as Deserializer};
+import{a}from"../chunk-N47FTRYO.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-KDMSOCZY.mjs";export{a as Deserializer};
 //# sourceMappingURL=deserializer.mjs.map

package/dist/esm/bcs/index.mjs

@@ -1,2 +1,2 @@
-import"../chunk-FZY4PMEE.mjs";import{a as p,b as q,c as r,d as s}from"../chunk-CCMHWJ3Q.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o}from"../chunk-6QGVRNV6.mjs";import{a as h}from"../chunk-YJCZU6PR.mjs";import{a as g}from"../chunk-MS4MRLGA.mjs";import{a}from"../chunk-KEYAPEAX.mjs";import"../chunk-44GYWUSH.mjs";import"../chunk-4WPQQPUF.mjs";import{a as b,b as c,c as d,d as e,e as f}from"../chunk-HPZ2S4FE.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-FVA2OPG4.mjs";export{i as Bool,a as Deserializer,h as EntryFunctionBytes,g as FixedBytes,s as MoveOption,r as MoveString,p as MoveVector,b as Serializable,q as Serialized,c as Serializer,n as U128,k as U16,o as U256,l as U32,m as U64,j as U8,d as ensureBoolean,e as outOfRangeErrorMessage,f as validateNumberInRange};
+import"../chunk-FZY4PMEE.mjs";import{a as p,b as q,c as r,d as s}from"../chunk-IECDO22V.mjs";import{a as h}from"../chunk-OZN3OOJV.mjs";import{a as g}from"../chunk-JGNMNCQB.mjs";import{a as i,b as j,c as k,d as l,e as m,f as n,g as o}from"../chunk-6FLHGOKP.mjs";import{a}from"../chunk-N47FTRYO.mjs";import"../chunk-7XS45O6M.mjs";import"../chunk-4WPQQPUF.mjs";import{a as b,b as c,c as d,d as e,e as f}from"../chunk-QQIVWB6G.mjs";import"../chunk-KFNDDPOW.mjs";import"../chunk-6Q2O5G3J.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-KDMSOCZY.mjs";export{i as Bool,a as Deserializer,h as EntryFunctionBytes,g as FixedBytes,s as MoveOption,r as MoveString,p as MoveVector,b as Serializable,q as Serialized,c as Serializer,n as U128,k as U16,o as U256,l as U32,m as U64,j as U8,d as ensureBoolean,e as outOfRangeErrorMessage,f as validateNumberInRange};
 //# sourceMappingURL=index.mjs.map

package/dist/esm/bcs/serializable/entryFunctionBytes.d.mts

@@ -14,8 +14,7 @@ import '../../types/generated/types.mjs';
  * This class exists solely to represent a sequence of fixed bytes as a serialized entry function, because
  * serializing an entry function appends a prefix that's *only* used for entry function arguments.
  *
- * NOTE: Attempting to use this class for a serialized script function will result in erroneous
- * and unexpected behavior.
+ * NOTE: Using this class for serialized script functions will lead to erroneous and unexpected behavior.
  *
  * If you wish to convert this class back to a TransactionArgument, you must know the type
  * of the argument beforehand, and use the appropriate class to deserialize the bytes within
@@ -23,16 +22,36 @@ import '../../types/generated/types.mjs';
  */
 declare class EntryFunctionBytes extends Serializable implements EntryFunctionArgument {
     readonly value: FixedBytes;
+    /**
+     * Creates an instance of the class with a specified hexadecimal input value.
+     *
+     * @param value - The hexadecimal input to be converted into FixedBytes.
+     */
     private constructor();
+    /**
+     * Serializes the value using the provided serializer.
+     * This function is essential for accurately representing a sequence of bytes that are already BCS-serialized as a type.
+     *
+     * Note that to see the Move, BCS-serialized representation of the underlying fixed byte vector,
+     * we must not serialize the length prefix.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     */
     serialize(serializer: Serializer): void;
+    /**
+     * Serializes the current instance for use as an entry function argument by converting the underlying fixed byte vector to a
+     * type-agnostic byte vector.
+     * This process includes serializing the length prefix of the byte vector.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     */
     serializeForEntryFunction(serializer: Serializer): void;
     /**
      * The only way to create an instance of this class is to use this static method.
-     *
      * This function should only be used when deserializing a sequence of EntryFunctionPayload arguments.
-     * @param deserializer the deserializer instance with the buffered bytes
-     * @param length the length of the bytes to deserialize
-     * @returns an instance of this class, which will now only be usable as an EntryFunctionArgument
+     * @param deserializer - The deserializer instance with the buffered bytes.
+     * @param length - The length of the bytes to deserialize.
+     * @returns An instance of this class, which will now only be usable as an EntryFunctionArgument.
      */
     static deserialize(deserializer: Deserializer, length: number): EntryFunctionBytes;
 }

package/dist/esm/bcs/serializable/entryFunctionBytes.mjs

@@ -1,2 +1,2 @@
-import{a}from"../../chunk-YJCZU6PR.mjs";import"../../chunk-MS4MRLGA.mjs";import"../../chunk-HPZ2S4FE.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-BCUSI3N6.mjs";import"../../chunk-LG7RJQ57.mjs";import"../../chunk-FVA2OPG4.mjs";export{a as EntryFunctionBytes};
+import{a}from"../../chunk-OZN3OOJV.mjs";import"../../chunk-JGNMNCQB.mjs";import"../../chunk-QQIVWB6G.mjs";import"../../chunk-KFNDDPOW.mjs";import"../../chunk-6Q2O5G3J.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-KDMSOCZY.mjs";export{a as EntryFunctionBytes};
 //# sourceMappingURL=entryFunctionBytes.mjs.map

package/dist/esm/bcs/serializable/fixedBytes.d.mts

@@ -10,42 +10,72 @@ import '../../types/generated/operations.mjs';
 import '../../types/generated/types.mjs';
 
 /**
- *  This class exists to represent a contiguous sequence of already serialized BCS-bytes.
+ * Represents a contiguous sequence of already serialized BCS bytes.
  *
- *  It differs from most other Serializable classes in that its internal byte buffer is serialized to BCS
- *  bytes exactly as-is, without prepending the length of the bytes.
+ * This class differs from most other Serializable classes in that its internal byte buffer is serialized to BCS
+ * bytes exactly as-is, without prepending the length of the bytes. It is ideal for scenarios where custom serialization
+ * is required, such as passing serialized bytes as transaction arguments. Additionally, it serves as a representation
+ * of type-agnostic BCS bytes, akin to a vector<u8>.
  *
- *  If you want to write your own serialization function and pass the bytes as a transaction argument,
- *  you should use this class.
+ * An example use case includes handling bytes resulting from entry function arguments that have been serialized
+ * for an entry function.
  *
- *  This class is also more generally used to represent type-agnostic BCS bytes as a vector<u8>.
- *
- *  An example of this is the bytes resulting from entry function arguments that have been serialized
- *  for an entry function.
- *
- *  @example
- *  const yourCustomSerializedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
- *  const fixedBytes = new FixedBytes(yourCustomSerializedBytes);
- *  const payload = await generateTransactionPayload({
- *    function: "0xbeefcafe::your_module::your_function_that_requires_custom_serialization",
- *    functionArguments: [yourCustomBytes],
- *  });
+ * @example
+ * const yourCustomSerializedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
+ * const fixedBytes = new FixedBytes(yourCustomSerializedBytes);
+ * const payload = await generateTransactionPayload({
+ *   function: "0xbeefcafe::your_module::your_function_that_requires_custom_serialization",
+ *   functionArguments: [yourCustomBytes],
+ * });
  *
+ * This class is particularly useful when you want to handle a fixed-size byte array without the overhead of
+ * length prepending, such as when dealing with 32-byte addresses stored as U8 in a MoveVector<U8>.
+
  *  For example, if you store each of the 32 bytes for an address as a U8 in a MoveVector<U8>, when you
  *  serialize that MoveVector<U8>, it will be serialized to 33 bytes. If you solely want to pass around
  *  the 32 bytes as a Serializable class that *does not* prepend the length to the BCS-serialized representation,
- *  use this class.
- *
- * @params value: HexInput representing a sequence of Uint8 bytes
- * @returns a Serializable FixedBytes instance, which when serialized, does not prepend the length of the bytes
+ *  use this class.*
+ * @param value - HexInput representing a sequence of Uint8 bytes.
+ * @returns A Serializable FixedBytes instance, which when serialized, does not prepend the length of the bytes.
  * @see EntryFunctionBytes
  */
 declare class FixedBytes extends Serializable implements TransactionArgument {
     value: Uint8Array;
+    /**
+     * Creates an instance of the class with a specified hexadecimal input.
+     * The value is converted from hexadecimal format to a Uint8Array.
+     *
+     * @param value - The hexadecimal input to be converted.
+     */
     constructor(value: HexInput);
+    /**
+     * Serializes the fixed bytes value using the provided serializer.
+     * This function is essential for converting the fixed bytes into a format suitable for storage or transmission.
+     *
+     * @param serializer - The serializer instance used for serialization.
+     */
     serialize(serializer: Serializer): void;
+    /**
+     * Serializes the current instance for an entry function using the provided serializer.
+     * This allows the instance to be converted into a format suitable for transmission or storage.
+     *
+     * @param serializer - The serializer used to perform the serialization.
+     */
     serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * Serializes the current instance using the provided serializer.
+     * This function is essential for preparing data to be passed as arguments in script functions.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     */
     serializeForScriptFunction(serializer: Serializer): void;
+    /**
+     * Deserializes a fixed-length byte array from the provided deserializer.
+     * This function helps in reconstructing a FixedBytes object from the serialized data.
+     *
+     * @param deserializer - The deserializer instance used to read the byte data.
+     * @param length - The length of the byte array to be deserialized.
+     */
     static deserialize(deserializer: Deserializer, length: number): FixedBytes;
 }
 

package/dist/esm/bcs/serializable/fixedBytes.mjs

@@ -1,2 +1,2 @@
-import{a}from"../../chunk-MS4MRLGA.mjs";import"../../chunk-HPZ2S4FE.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-BCUSI3N6.mjs";import"../../chunk-LG7RJQ57.mjs";import"../../chunk-FVA2OPG4.mjs";export{a as FixedBytes};
+import{a}from"../../chunk-JGNMNCQB.mjs";import"../../chunk-QQIVWB6G.mjs";import"../../chunk-KFNDDPOW.mjs";import"../../chunk-6Q2O5G3J.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-KDMSOCZY.mjs";export{a as FixedBytes};
 //# sourceMappingURL=fixedBytes.mjs.map

package/dist/esm/bcs/serializable/movePrimitives.d.mts

@@ -9,14 +9,57 @@ import '../../types/generated/types.mjs';
 import '../../core/hex.mjs';
 import '../../core/common.mjs';
 
+/**
+ * Represents a boolean value that can be serialized and deserialized.
+ * This class extends the Serializable class and provides methods to serialize
+ * the boolean value for different contexts, such as entry functions and script functions.
+ *
+ * @extends Serializable
+ */
 declare class Bool extends Serializable implements TransactionArgument {
     readonly value: boolean;
+    /**
+     * Constructs a new instance with a specified value.
+     * This ensures that the value is validated to be within the acceptable range.
+     *
+     * @param value - The number to be validated and assigned, which must be between 0 and MAX_U256_BIG_INT.
+     */
     constructor(value: boolean);
+    /**
+     * Serializes the value using the provided serializer.
+     * This function is essential for converting the value into a format suitable for transmission or storage.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     */
     serialize(serializer: Serializer): void;
+    /**
+     * Serializes the current instance for use in an entry function by converting it to a byte sequence.
+     * This allows the instance to be properly formatted for serialization in transactions.
+     *
+     * @param serializer - The serializer instance used to serialize the byte sequence.
+     */
     serializeForEntryFunction(serializer: Serializer): void;
+    /**
+     * Serializes the current instance for use in a script function.
+     * This allows for the conversion of the instance into a format suitable for transmission or storage.
+     *
+     * @param serializer - The serializer used to perform the serialization.
+     */
     serializeForScriptFunction(serializer: Serializer): void;
+    /**
+     * Deserializes a U256 value from the provided deserializer.
+     *
+     * @param deserializer - The deserializer instance used to read the U256 data.
+     */
+    deserialize(deserializer: Deserializer): U256;
     static deserialize(deserializer: Deserializer): Bool;
 }
+/**
+ * Represents an unsigned 8-bit integer (U8) value.
+ * This class extends the Serializable class and provides methods for serialization and deserialization of U8 values.
+ *
+ * @extends Serializable
+ */
 declare class U8 extends Serializable implements TransactionArgument {
     readonly value: Uint8;
     constructor(value: Uint8);
@@ -25,6 +68,13 @@ declare class U8 extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): U8;
 }
+/**
+ * Represents a 16-bit unsigned integer (U16) value.
+ * This class extends the Serializable class and provides methods for serialization
+ * and deserialization of the U16 value.
+ *
+ * @extends Serializable
+ */
 declare class U16 extends Serializable implements TransactionArgument {
     readonly value: Uint16;
     constructor(value: Uint16);
@@ -33,6 +83,12 @@ declare class U16 extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): U16;
 }
+/**
+ * Represents a 32-bit unsigned integer (U32) that can be serialized and deserialized.
+ * This class ensures that the value is within the valid range for a U32.
+ *
+ * @extends Serializable
+ */
 declare class U32 extends Serializable implements TransactionArgument {
     readonly value: Uint32;
     constructor(value: Uint32);
@@ -41,6 +97,15 @@ declare class U32 extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): U32;
 }
+/**
+ * Represents a 64-bit unsigned integer (U64) and provides methods for serialization.
+ *
+ * This class ensures that the value is within the valid range for a U64 and provides
+ * functionality to serialize the value for various use cases, including entry functions
+ * and script functions.
+ *
+ * @extends Serializable
+ */
 declare class U64 extends Serializable implements TransactionArgument {
     readonly value: bigint;
     constructor(value: AnyNumber);
@@ -49,6 +114,13 @@ declare class U64 extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): U64;
 }
+/**
+ * Represents a 128-bit unsigned integer value.
+ * This class provides methods for serialization and deserialization
+ * of U128 values, ensuring that the values are within the valid range.
+ *
+ * @extends Serializable
+ */
 declare class U128 extends Serializable implements TransactionArgument {
     readonly value: bigint;
     constructor(value: AnyNumber);
@@ -57,6 +129,13 @@ declare class U128 extends Serializable implements TransactionArgument {
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): U128;
 }
+/**
+ * Represents a 256-bit unsigned integer (U256) that extends the Serializable class.
+ * This class provides methods for serialization and deserialization of U256 values,
+ * ensuring that the values are within the valid range.
+ *
+ * @extends Serializable
+ */
 declare class U256 extends Serializable implements TransactionArgument {
     readonly value: bigint;
     constructor(value: AnyNumber);

package/dist/esm/bcs/serializable/movePrimitives.mjs

@@ -1,2 +1,2 @@
-import{a,b,c,d,e,f,g}from"../../chunk-6QGVRNV6.mjs";import"../../chunk-44GYWUSH.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-HPZ2S4FE.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-BCUSI3N6.mjs";import"../../chunk-LG7RJQ57.mjs";import"../../chunk-FVA2OPG4.mjs";export{a as Bool,f as U128,c as U16,g as U256,d as U32,e as U64,b as U8};
+import{a,b,c,d,e,f,g}from"../../chunk-6FLHGOKP.mjs";import"../../chunk-7XS45O6M.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-QQIVWB6G.mjs";import"../../chunk-KFNDDPOW.mjs";import"../../chunk-6Q2O5G3J.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-KDMSOCZY.mjs";export{a as Bool,f as U128,c as U16,g as U256,d as U32,e as U64,b as U8};
 //# sourceMappingURL=movePrimitives.mjs.map