@aptos-labs/ts-sdk 1.29.0 → 1.30.0

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

@@ -50,85 +50,148 @@ import '../../core/common.mjs';
  */
 declare class MoveVector<T extends Serializable & EntryFunctionArgument> extends Serializable implements TransactionArgument {
     values: Array<T>;
+    /**
+     * Initializes a new instance of the class with an optional value.
+     * This constructor sets up the internal vector based on the provided value.
+     *
+     * @param values - The initial value to be stored in the vector, or null to initialize an empty vector.
+     */
     constructor(values: Array<T>);
+    /**
+     * Serializes the current instance into a byte sequence suitable for entry functions.
+     * This allows the data to be properly formatted for transmission or storage.
+     *
+     * @param serializer - The serializer instance used to serialize the byte sequence.
+     */
     serializeForEntryFunction(serializer: Serializer): void;
     /**
      * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.
      * @param serializer
      */
+    /**
+     * Serialize the string as a fixed byte string without the length prefix for use in a script function.
+     * @param serializer - The serializer used to convert the byte vector into a format suitable for a script function.
+     */
     serializeForScriptFunction(serializer: Serializer): void;
     /**
-     * Factory method to generate a MoveVector of U8s from an array of numbers.
+     * Factory method to generate a MoveVector<U8> from a `number` or `undefined`.
+     *
+     * This method allows you to create a MoveVector that encapsulates a U8 value, enabling you to handle optional U8 values
+     * effectively.
+     *
+     * @param values - The values used to fill the MoveVector. If `values` is undefined or null, the resulting MoveVector's
+     * `.isSome()` method will return false.
+     * @returns A MoveVector<U8> with an inner value `value`.
      *
      * @example
+     * ```typescript
      * const v = MoveVector.U8([1, 2, 3, 4]);
-     * @params values: an array of `numbers` to convert to U8s
-     * @returns a `MoveVector<U8>`
+     * ```
      */
     static U8(values: Array<number> | HexInput): MoveVector<U8>;
     /**
-     * Factory method to generate a MoveVector of U16s from an array of numbers.
+     * Factory method to generate a MoveOption<U16> from a `number` or `null`.
+     *
+     * This method allows you to create a MoveVector that can either hold a U16 value or be empty.
      *
+     * @param values - The value used to fill the MoveVector. If `value` is null or undefined, the resulting MoveVector's
+     * `.isSome()` method will return false.
+     * @returns A MoveVector<U16> with an inner value `value`.
      * @example
+     * ```typescript
      * const v = MoveVector.U16([1, 2, 3, 4]);
-     * @params values: an array of `numbers` to convert to U16s
-     * @returns a `MoveVector<U16>`
+     * ```
+  
      */
     static U16(values: Array<number>): MoveVector<U16>;
     /**
-     * Factory method to generate a MoveVector of U32s from an array of numbers.
+     * Factory method to generate a MoveVector<U32> from a `number` or `null`.
+     *
+     * This method allows you to create a MoveVector that can either hold a U32 value or be empty.
+     *
+     * @param values - The value used to fill the MoveVector. If `value` is null or undefined,
+     * the resulting MoveVector's .isSome() method will return false.
+     * @returns A MoveVector<U32> with an inner value `value`.
      *
      * @example
+     * ```
      * const v = MoveVector.U32([1, 2, 3, 4]);
-     * @params values: an array of `numbers` to convert to U32s
-     * @returns a `MoveVector<U32>`
+     * ```
+  
      */
     static U32(values: Array<number>): MoveVector<U32>;
     /**
-     * Factory method to generate a MoveVector of U64s from an array of numbers or bigints.
+     * Factory method to generate a MoveVector<U64> from a number, bigint, or null/undefined.
+     * This allows for the creation of an optional U64 value that can be checked for presence.
+     *
+     * @param values - The value used to fill the MoveVector. If `value` is undefined or null, the resulting MoveVector's
+     * `.isSome()` method will return false.
+     * @returns A MoveVector<U64> with an inner value `value`.
      *
      * @example
+     * ```typescript
      * const v = MoveVector.U64([1, 2, 3, 4]);
-     * @params values: an array of numbers of type `number | bigint` to convert to U64s
-     * @returns a `MoveVector<U64>`
+     * ```
      */
     static U64(values: Array<AnyNumber>): MoveVector<U64>;
     /**
-     * Factory method to generate a MoveVector of U128s from an array of numbers or bigints.
+     * Factory method to generate a MoveVector<U128> from a number, bigint, or undefined.
+     *
+     * @param values - The value used to fill the MoveVector. If `value` is undefined, the resulting MoveVector's `.isSome()`
+     * method will return false.
+     * @returns A MoveVector<U128> with an inner value `value`.
      *
      * @example
+     * ```typescript
      * const v = MoveVector.U128([1, 2, 3, 4]);
-     * @params values: an array of numbers of type `number | bigint` to convert to U128s
-     * @returns a `MoveVector<U128>`
+     * ```
      */
     static U128(values: Array<AnyNumber>): MoveVector<U128>;
     /**
-     * Factory method to generate a MoveVector of U256s from an array of numbers or bigints.
+     * Factory method to generate a MoveVector<U256> from a number, bigint, or null/undefined.
+     * This allows for the creation of an optional U256 value, enabling checks for presence or absence of a value.
+     *
+     * @param values - The value used to fill the MoveVector. If `value` is undefined or null,
+     *                the resulting MoveVector's .isSome() method will return false.
+     * @returns A MoveVector<U256> with an inner value `value`.
      *
      * @example
+     * ```typescript
      * const v = MoveVector.U256([1, 2, 3, 4]);
-     * @params values: an array of numbers of type `number | bigint` to convert to U256s
-     * @returns a `MoveVector<U256>`
+     * ```
      */
     static U256(values: Array<AnyNumber>): MoveVector<U256>;
     /**
-     * Factory method to generate a MoveVector of Bools from an array of booleans.
+     * Factory method to generate a MoveVector<Bool> from a `boolean` or `undefined`.
+     * This method allows you to create an optional boolean value that can be used in various contexts where a boolean may or may
+     * not be present.
+     *
+     * @param values - The value used to fill the MoveVector. If `value` is undefined, the resulting MoveVector's .isSome() method
+     * will return false.
+     * @returns A MoveVector<Bool> with an inner value `value`.
      *
      * @example
-     * const v = MoveVector.Bool([true, false, true, false]);
-     * @params values: an array of `bools` to convert to Bools
-     * @returns a `MoveVector<Bool>`
+     *    * const v = MoveVector.Bool([true, false, true, false]);
      */
     static Bool(values: Array<boolean>): MoveVector<Bool>;
     /**
-     * Factory method to generate a MoveVector of MoveStrings from an array of strings.
+     * Factory method to generate a MoveVector<MoveString> from a `string` or `undefined`.
+     * This function creates a MoveVector that encapsulates a MoveString if the provided value is not null or undefined.
+     *
+     * @param values - The value used to fill the MoveVector. If `value` is undefined, the resulting MoveVector's .isSome() method
+     * will return false.
+     * @returns A MoveVector<MoveString> with an inner value `value`.
      *
      * @example
      * const v = MoveVector.MoveString(["hello", "world"]);
-     * @params values: an array of `strings` to convert to MoveStrings
-     * @returns a `MoveVector<MoveString>`
      */
     static MoveString(values: Array<string>): MoveVector<MoveString>;
+    /**
+     * Serializes the current object using the provided serializer.
+     * This function will serialize the value if it is present.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     */
     serialize(serializer: Serializer): void;
     /**
      * Deserialize a MoveVector of type T, specifically where T is a Serializable and Deserializable type.
@@ -142,13 +205,20 @@ declare class MoveVector<T extends Serializable & EntryFunctionArgument> extends
      *
      * @example
      * const vec = MoveVector.deserialize(deserializer, U64);
-     * @params deserializer: the Deserializer instance to use, with bytes loaded into it already.
-     * cls: the class to typecast the input values to, must be a Serializable and Deserializable type.
+     * @param deserializer the Deserializer instance to use, with bytes loaded into it already.
+     * @param cls the class to typecast the input values to, must be a Serializable and Deserializable type.
      * @returns a MoveVector of the corresponding class T
-     * *
+     *
      */
     static deserialize<T extends Serializable & EntryFunctionArgument>(deserializer: Deserializer, cls: Deserializable<T>): MoveVector<T>;
 }
+/**
+ * Represents a serialized data structure that encapsulates a byte array.
+ * This class extends the Serializable class and provides methods for serialization
+ * and deserialization of byte data, as well as converting to a MoveVector.
+ *
+ * @extends Serializable
+ */
 declare class Serialized extends Serializable implements TransactionArgument {
     readonly value: Uint8Array;
     constructor(value: HexInput);
@@ -156,8 +226,22 @@ declare class Serialized extends Serializable implements TransactionArgument {
     serializeForEntryFunction(serializer: Serializer): void;
     serializeForScriptFunction(serializer: Serializer): void;
     static deserialize(deserializer: Deserializer): Serialized;
+    /**
+     * Deserialize the bytecode into a MoveVector of the specified type.
+     * This function allows you to convert serialized data into a usable MoveVector format.
+     *
+     * @param cls - The class type of the elements in the MoveVector.
+     */
     toMoveVector<T extends Serializable & EntryFunctionArgument>(cls: Deserializable<T>): MoveVector<T>;
 }
+/**
+ * Represents a string value that can be serialized and deserialized.
+ * This class extends the Serializable base class and provides methods
+ * for serializing the string in different contexts, such as for entry
+ * functions and script functions.
+ *
+ * @extends Serializable
+ */
 declare class MoveString extends Serializable implements TransactionArgument {
     value: string;
     constructor(value: string);
@@ -174,10 +258,8 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
     /**
      * Retrieves the inner value of the MoveOption.
      *
-     * This method is inspired by Rust's `Option<T>.unwrap()`.
-     * In Rust, attempting to unwrap a `None` value results in a panic.
-     *
-     * Similarly, this method will throw an error if the value is not present.
+     * This method is inspired by Rust's `Option<T>.unwrap()`, where attempting to unwrap a `None` value results in a panic.
+     * This method will throw an error if the value is not present.
      *
      * @example
      * const option = new MoveOption<Bool>(new Bool(true));
@@ -188,6 +270,11 @@ declare class MoveOption<T extends Serializable & EntryFunctionArgument> extends
      * @returns {T} The contained value if present.
      */
     unwrap(): T;
+    /**
+     * Check if the MoveOption has a value.
+     *
+     * @returns {boolean} Returns true if there is exactly one value in the MoveOption.
+     */
     isSome(): boolean;
     serialize(serializer: Serializer): void;
     /**

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

@@ -1,2 +1,2 @@
-import{a,b,c,d}from"../../chunk-LNEZEYYE.mjs";import"../../chunk-YPHH6CAO.mjs";import"../../chunk-44GYWUSH.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-A63SMUOU.mjs";import"../../chunk-BCUSI3N6.mjs";import"../../chunk-LG7RJQ57.mjs";import"../../chunk-KEYAPEAX.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-FVA2OPG4.mjs";export{d as MoveOption,c as MoveString,a as MoveVector,b as Serialized};
+import{a,b,c,d}from"../../chunk-IECDO22V.mjs";import"../../chunk-6FLHGOKP.mjs";import"../../chunk-N47FTRYO.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{d as MoveOption,c as MoveString,a as MoveVector,b as Serialized};
 //# sourceMappingURL=moveStructs.mjs.map

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

@@ -6,38 +6,86 @@ import '../types/indexer.mjs';
 import '../types/generated/operations.mjs';
 import '../types/generated/types.mjs';
 
+/**
+ * This class serves as a base class for all serializable types. It facilitates
+ * composable serialization of complex types and enables the serialization of
+ * instances to their BCS (Binary Canonical Serialization) representation.
+ */
 declare abstract class Serializable {
     abstract serialize(serializer: Serializer): void;
     /**
      * Serializes a `Serializable` value to its BCS representation.
-     * This function is the Typescript SDK equivalent of `bcs::to_bytes` in Move.
-     * @returns the BCS representation of the Serializable instance as a byte buffer
+     * This function is the TypeScript SDK equivalent of `bcs::to_bytes` in Move.
+     * @returns the BCS representation of the Serializable instance as a byte buffer.
      */
     bcsToBytes(): Uint8Array;
     /**
-     * Helper function to get a value's BCS-serialized bytes as a Hex instance.
-     * @returns a Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array
+     * Converts the BCS-serialized bytes of a value into a Hex instance.
+     * This function provides a Hex representation of the BCS-serialized data for easier handling and manipulation.
+     * @returns A Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array.
      */
     bcsToHex(): Hex;
+    /**
+     * Returns the hex string representation of the `Serializable` value without the 0x prefix.
+     * @returns the hex format as a string without `0x` prefix.
+     */
+    toStringWithoutPrefix(): string;
+    /**
+     * Returns the hex string representation of the `Serializable` value with the 0x prefix.
+     * @returns the hex formatas a string prefixed by `0x`.
+     */
+    toString(): string;
 }
+/**
+ * A class for serializing various data types into a binary format.
+ * It provides methods to serialize strings, bytes, numbers, and other serializable objects
+ * using the Binary Coded Serialization (BCS) layout. The serialized data can be retrieved as a
+ * Uint8Array.
+ */
 declare class Serializer {
     private buffer;
     private offset;
+    /**
+     * Constructs a serializer with a buffer of size `length` bytes, 64 bytes by default.
+     * The `length` must be greater than 0.
+     *
+     * @param length - The size of the buffer in bytes.
+     */
     constructor(length?: number);
+    /**
+     * Ensures that the internal buffer can accommodate the specified number of bytes.
+     * This function dynamically resizes the buffer if the current size is insufficient.
+     *
+     * @param bytes - The number of bytes to ensure the buffer can handle.
+     */
     private ensureBufferWillHandleSize;
+    /**
+     * Appends the specified values to the buffer, ensuring that the buffer can accommodate the new data.
+     *
+     * @param {Uint8Array} values - The values to be appended to the buffer.
+     */
     protected appendToBuffer(values: Uint8Array): void;
+    /**
+     * Serializes a value into the buffer using the provided function, ensuring the buffer can accommodate the size.
+     *
+     * @param fn - The function to serialize the value, which takes a byte offset, the value to serialize, and an optional little-endian flag.
+     * @param fn.byteOffset - The byte offset at which to write the value.
+     * @param fn.value - The numeric value to serialize into the buffer.
+     * @param fn.littleEndian - Optional flag indicating whether to use little-endian byte order (defaults to true).
+     */
     private serializeWithFunction;
     /**
      * Serializes a string. UTF8 string is supported.
-     *
      * The number of bytes in the string content is serialized first, as a uleb128-encoded u32 integer.
      * Then the string content is serialized as UTF8 encoded bytes.
      *
      * 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.
      *
+     * @param value - The string to serialize.
+     *
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeStr("1234abcd");
      * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
@@ -47,35 +95,47 @@ declare class Serializer {
     /**
      * Serializes an array of bytes.
      *
+     * This function encodes the length of the byte array as a u32 integer in uleb128 format, followed by the byte array itself.
      * 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.
+     * @param value - The byte array to serialize.
      */
     serializeBytes(value: Uint8Array): void;
     /**
-     * Serializes an array of bytes with known length. Therefore, length doesn't need to be
-     * serialized to help deserialization.
-     *
+     * Serializes an array of bytes with a known length, allowing for efficient deserialization without needing to serialize the
+     * length itself.
      * When deserializing, the number of bytes to deserialize needs to be passed in.
+  
+     * @param value - The Uint8Array to be serialized.
      */
     serializeFixedBytes(value: Uint8Array): void;
     /**
-     * Serializes a boolean value.
+     * Serializes a boolean value into a byte representation.
+     *
+     * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
      *
-     * BCS layout for "boolean": One byte. "0x01" for true and "0x00" for false.
+     * @param value - The boolean value to serialize.
      */
     serializeBool(value: boolean): void;
     /**
-     * Serializes a uint8 number.
-     *
+     * Serializes a Uint8 value and appends it to the buffer.
      * BCS layout for "uint8": One byte. Binary format in little-endian representation.
+     *
+     * @param value - The Uint8 value to serialize.
      */
     serializeU8(value: Uint8): void;
     /**
      * Serializes a uint16 number.
      *
+  
+     */
+    /**
+     * Serializes a 16-bit unsigned integer value into a binary format.
      * BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
+     *
+     * @param value - The 16-bit unsigned integer value to serialize.
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeU16(4660);
      * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));
@@ -83,21 +143,22 @@ declare class Serializer {
      */
     serializeU16(value: Uint16): void;
     /**
-     * Serializes a uint32 number.
-     *
-     * BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
+     * Serializes a 32-bit unsigned integer value into a binary format.
+     * This function is useful for encoding data that needs to be stored or transmitted in a compact form.
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeU32(305419896);
      * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
      * ```
+     * @param value - The 32-bit unsigned integer value to serialize.
      */
     serializeU32(value: Uint32): void;
     /**
-     * Serializes a uint64 number.
+     * Serializes a 64-bit unsigned integer into a format suitable for storage or transmission.
+     * This function breaks down the value into two 32-bit components and writes them in little-endian order.
      *
-     * BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
+     * @param value - The 64-bit unsigned integer to serialize, represented as a number.
      * @example
      * ```ts
      * const serializer = new Serializer();
@@ -107,66 +168,44 @@ declare class Serializer {
      */
     serializeU64(value: AnyNumber): void;
     /**
-     * Serializes a uint128 number.
+     * Serializes a U128 value into a format suitable for storage or transmission.
      *
-     * BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
+     * @param value - The U128 value to serialize, represented as a number.
      */
     serializeU128(value: AnyNumber): void;
     /**
-     * Serializes a uint256 number.
+     * Serializes a U256 value into a byte representation.
+     * This function is essential for encoding large numbers in a compact format suitable for transmission or storage.
      *
-     * BCS layout for "uint256": Sixteen bytes. Binary format in little-endian representation.
+     * @param value - The U256 value to serialize, represented as an AnyNumber.
      */
     serializeU256(value: AnyNumber): void;
     /**
-     * Serializes a uint32 number with uleb128.
-     *
+     * Serializes a 32-bit unsigned integer as a variable-length ULEB128 encoded byte array.
      * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
+     *
+     * @param val - The 32-bit unsigned integer value to be serialized.
      */
     serializeU32AsUleb128(val: Uint32): void;
     /**
-     * Returns the buffered bytes
+     * Returns the buffered bytes as a Uint8Array.
+     *
+     * This function allows you to retrieve the byte representation of the buffer up to the current offset.
+     *
+     * @returns Uint8Array - The byte array representation of the buffer.
      */
     toUint8Array(): Uint8Array;
     /**
      * Serializes a `Serializable` value, facilitating composable serialization.
      *
-     * @param value The Serializable value to serialize
-     *
-     * @example
-     * // Define the MoveStruct class that implements the Serializable interface
-     * class MoveStruct extends Serializable {
-     *     constructor(
-     *         public creatorAddress: AccountAddress, // where AccountAddress extends Serializable
-     *         public collectionName: string,
-     *         public tokenName: string
-     *     ) {}
-     *
-     *     serialize(serializer: Serializer): void {
-     *         serializer.serialize(this.creatorAddress);  // Composable serialization of another Serializable object
-     *         serializer.serializeStr(this.collectionName);
-     *         serializer.serializeStr(this.tokenName);
-     *     }
-     * }
-     *
-     * // Construct a MoveStruct
-     * const moveStruct = new MoveStruct(new AccountAddress(...), "MyCollection", "TokenA");
-     *
-     * // Serialize a string, a u64 number, and a MoveStruct instance.
-     * const serializer = new Serializer();
-     * serializer.serializeStr("ExampleString");
-     * serializer.serializeU64(12345678);
-     * serializer.serialize(moveStruct);
-     *
-     * // Get the bytes from the Serializer instance
-     * const serializedBytes = serializer.toUint8Array();
+     * @param value The Serializable value to serialize.
      *
      * @returns the serializer instance
      */
     serialize<T extends Serializable>(value: T): void;
     /**
      * Serializes an array of BCS Serializable values to a serializer instance.
-     * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+     * The bytes are added to the serializer instance's byte buffer.
      *
      * @param values The array of BCS Serializable values
      * @example
@@ -185,13 +224,13 @@ declare class Serializer {
      */
     serializeVector<T extends Serializable>(values: Array<T>): void;
     /**
-     * Serializes a BCS Serializable values into a serializer instance or undefined.
-     * Note that this does not return anything. The bytes are added to the serializer instance's byte buffer.
+     * Serializes a BCS Serializable value into a serializer instance or handles the case when the value is undefined.
+     * This function allows you to efficiently add serialized data to the serializer's byte buffer.
      *
-     * @param values The array of BCS Serializable values
+     * @param value The BCS Serializable value to serialize, or undefined if there is no value.
      *
      * @example
-     * ```ts
+     * ```typescript
      * const serializer = new Serializer();
      * serializer.serializeOption(new AccountAddress(...));
      * const serializedBytes = serializer.toUint8Array();
@@ -204,31 +243,27 @@ declare class Serializer {
      */
     serializeOption<T extends Serializable>(value?: T): void;
     /**
-     * Serializes an optional string. UTF8 string is supported.
-     *
-     * The existence of the string is encoded first, 0 if undefined and 1 if it exists.
-     * Them the number of bytes in the string content is serialized, as a uleb128-encoded u32 integer.
-     * Then the string content is serialized as UTF8 encoded bytes.
+     * Serializes an optional string, supporting UTF8 encoding.
+     * The function encodes the existence of the string first, followed by the length and content if it exists.
      *
      * BCS layout for optional "string": 1 | 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.
-     *
      * BCS layout for undefined: 0
-     * @example
-     * ```ts
-     * const serializer = new Serializer();
-     * serializer.serializeOptionStr("1234abcd");
-     * assert(serializer.toUint8Array() === new Uint8Array([1, 8, 49, 50, 51, 52, 97, 98, 99, 100]));
      *
-     * const serializer = new Serializer();
-     * serializer.serializeOptionStr(undefined);
-     * assert(serializer.toUint8Array() === new Uint8Array([0]));
-     * ```
+     * @param value - The optional string to serialize. If undefined, it will serialize as 0.
      */
     serializeOptionStr(value?: string): void;
 }
 declare function ensureBoolean(value: unknown): asserts value is boolean;
 declare const outOfRangeErrorMessage: (value: AnyNumber, min: AnyNumber, max: AnyNumber) => string;
+/**
+ * Validates that a given number is within a specified range.
+ * This function throws an error if the value is outside the defined minimum and maximum bounds.
+ *
+ * @param value - The number to validate.
+ * @param minValue - The minimum allowable value (inclusive).
+ * @param maxValue - The maximum allowable value (inclusive).
+ */
 declare function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T): void;
 
 export { Serializable, Serializer, ensureBoolean, outOfRangeErrorMessage, validateNumberInRange };

package/dist/esm/bcs/serializer.mjs

@@ -1,2 +1,2 @@
-import{a,b,c,d,e}from"../chunk-A63SMUOU.mjs";import"../chunk-BCUSI3N6.mjs";import"../chunk-LG7RJQ57.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-FVA2OPG4.mjs";export{a as Serializable,b as Serializer,c as ensureBoolean,d as outOfRangeErrorMessage,e as validateNumberInRange};
+import{a,b,c,d,e}from"../chunk-QQIVWB6G.mjs";import"../chunk-KFNDDPOW.mjs";import"../chunk-6Q2O5G3J.mjs";import"../chunk-56CNRT2K.mjs";import"../chunk-KDMSOCZY.mjs";export{a as Serializable,b as Serializer,c as ensureBoolean,d as outOfRangeErrorMessage,e as validateNumberInRange};
 //# sourceMappingURL=serializer.mjs.map

package/dist/esm/{chunk-U6Z4FNB7.mjs → chunk-2CJC43CV.mjs}

@@ -1,2 +1,2 @@
 var i=class{constructor(){this.queue=[];this.pendingDequeue=[];this.cancelled=!1}enqueue(e){if(this.cancelled=!1,this.pendingDequeue.length>0){this.pendingDequeue.shift()?.resolve(e);return}this.queue.push(e)}async dequeue(){return this.queue.length>0?Promise.resolve(this.queue.shift()):new Promise((e,u)=>{this.pendingDequeue.push({resolve:e,reject:u})})}isEmpty(){return this.queue.length===0}cancel(){this.cancelled=!0,this.pendingDequeue.forEach(async({reject:e})=>{e(new n("Task cancelled"))}),this.pendingDequeue=[],this.queue.length=0}isCancelled(){return this.cancelled}pendingDequeueLength(){return this.pendingDequeue.length}},n=class extends Error{};export{i as a,n as b};
-//# sourceMappingURL=chunk-U6Z4FNB7.mjs.map
+//# sourceMappingURL=chunk-2CJC43CV.mjs.map

package/dist/esm/chunk-2CJC43CV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/transactions/management/asyncQueue.ts"],"sourcesContent":["/**\n * The AsyncQueue class is an async-aware data structure that provides a queue-like\n * behavior for managing asynchronous tasks or operations.\n * It allows to enqueue items and dequeue them asynchronously.\n * This is not thread-safe, but it is async concurrency safe, and\n * it does not guarantee ordering for those that call into and await on enqueue.\n */\n\ninterface PendingDequeue<T> {\n  resolve: (value: T) => void;\n  reject: (reason?: AsyncQueueCancelledError) => void;\n}\n\nexport class AsyncQueue<T> {\n  readonly queue: T[] = [];\n\n  // The pendingDequeue is used to handle the resolution of promises when items are enqueued and dequeued.\n  private pendingDequeue: PendingDequeue<T>[] = [];\n\n  private cancelled: boolean = false;\n\n  /**\n   * Adds an item to the queue. If there are pending dequeued promises, it resolves the oldest promise with the enqueued item\n   * immediately; otherwise, it adds the item to the queue.\n   *\n   * @param item - The item to be added to the queue.\n   */\n  enqueue(item: T): void {\n    this.cancelled = false;\n\n    if (this.pendingDequeue.length > 0) {\n      const promise = this.pendingDequeue.shift();\n\n      promise?.resolve(item);\n\n      return;\n    }\n\n    this.queue.push(item);\n  }\n\n  /**\n   * Dequeues the next item from the queue and returns a promise that resolves to it.\n   * If the queue is empty, it creates a new promise that will be resolved when an item is enqueued.\n   *\n   * @returns Promise<T>\n   */\n  async dequeue(): Promise<T> {\n    if (this.queue.length > 0) {\n      return Promise.resolve(this.queue.shift()!);\n    }\n\n    return new Promise<T>((resolve, reject) => {\n      this.pendingDequeue.push({ resolve, reject });\n    });\n  }\n\n  /**\n   * Determine whether the queue is empty.\n   *\n   * @returns boolean - Returns true if the queue has no elements, otherwise false.\n   */\n  isEmpty(): boolean {\n    return this.queue.length === 0;\n  }\n\n  /**\n   * Cancels all pending promises in the queue and rejects them with an AsyncQueueCancelledError.\n   * This ensures that any awaiting code can handle the cancellation appropriately.\n   *\n   * @returns {void}\n   */\n  cancel(): void {\n    this.cancelled = true;\n\n    this.pendingDequeue.forEach(async ({ reject }) => {\n      reject(new AsyncQueueCancelledError(\"Task cancelled\"));\n    });\n\n    this.pendingDequeue = [];\n\n    this.queue.length = 0;\n  }\n\n  /**\n   * Determine whether the queue has been cancelled.\n   *\n   * @returns boolean - Returns true if the queue is cancelled, otherwise false.\n   */\n  isCancelled(): boolean {\n    return this.cancelled;\n  }\n\n  /**\n   * Retrieve the length of the pending dequeue.\n   *\n   * @returns number - The number of items currently in the pending dequeue.\n   */\n  pendingDequeueLength(): number {\n    return this.pendingDequeue.length;\n  }\n}\n\n/**\n * Represents an error that occurs when an asynchronous queue operation is cancelled.\n * This error extends the built-in Error class to provide additional context for cancellation events.\n *\n * @extends Error\n */\nexport class AsyncQueueCancelledError extends Error {}\n"],"mappings":"AAaO,IAAMA,EAAN,KAAoB,CAApB,cACL,KAAS,MAAa,CAAC,EAGvB,KAAQ,eAAsC,CAAC,EAE/C,KAAQ,UAAqB,GAQ7B,QAAQC,EAAe,CAGrB,GAFA,KAAK,UAAY,GAEb,KAAK,eAAe,OAAS,EAAG,CAClB,KAAK,eAAe,MAAM,GAEjC,QAAQA,CAAI,EAErB,MACF,CAEA,KAAK,MAAM,KAAKA,CAAI,CACtB,CAQA,MAAM,SAAsB,CAC1B,OAAI,KAAK,MAAM,OAAS,EACf,QAAQ,QAAQ,KAAK,MAAM,MAAM,CAAE,EAGrC,IAAI,QAAW,CAACC,EAASC,IAAW,CACzC,KAAK,eAAe,KAAK,CAAE,QAAAD,EAAS,OAAAC,CAAO,CAAC,CAC9C,CAAC,CACH,CAOA,SAAmB,CACjB,OAAO,KAAK,MAAM,SAAW,CAC/B,CAQA,QAAe,CACb,KAAK,UAAY,GAEjB,KAAK,eAAe,QAAQ,MAAO,CAAE,OAAAA,CAAO,IAAM,CAChDA,EAAO,IAAIC,EAAyB,gBAAgB,CAAC,CACvD,CAAC,EAED,KAAK,eAAiB,CAAC,EAEvB,KAAK,MAAM,OAAS,CACtB,CAOA,aAAuB,CACrB,OAAO,KAAK,SACd,CAOA,sBAA+B,CAC7B,OAAO,KAAK,eAAe,MAC7B,CACF,EAQaA,EAAN,cAAuC,KAAM,CAAC","names":["AsyncQueue","item","resolve","reject","AsyncQueueCancelledError"]}

package/dist/esm/{chunk-P2EIZ7WL.mjs → chunk-2I56E4T2.mjs}

@@ -1,2 +1,2 @@
-import{a as y,f as P,g as C,i as b}from"./chunk-MDJ66AA3.mjs";import{a as I}from"./chunk-STUXKQVZ.mjs";import{a as f}from"./chunk-RXE6NNOL.mjs";import{a as w}from"./chunk-QPB6EJVM.mjs";import{a as A}from"./chunk-Y3BATGHX.mjs";import{d as h}from"./chunk-O2BPA6TS.mjs";import{a as l}from"./chunk-SWNFKKRE.mjs";import{c as T,m as c}from"./chunk-SUJLWCRN.mjs";import{b as p}from"./chunk-OHRL766V.mjs";import{b as d}from"./chunk-CRA2MFJC.mjs";import{a as s}from"./chunk-LNEZEYYE.mjs";import{b as m}from"./chunk-YPHH6CAO.mjs";async function S(t){let e=await K(t);return U(t,e)}async function K(t){let{aptosConfig:e,data:n}=t,a,o;return"bytecode"in n?o=await y(n):"multisigAddress"in n?(a={aptosConfig:e,multisigAddress:n.multisigAddress,function:n.function,functionArguments:n.functionArguments,typeArguments:n.typeArguments,abi:n.abi},o=await y(a)):(a={aptosConfig:e,function:n.function,functionArguments:n.functionArguments,typeArguments:n.typeArguments,abi:n.abi},o=await y(a)),o}async function U(t,e){let{aptosConfig:n,sender:a,options:o}=t,i;if(_(t)&&(i=p.ZERO.toString()),B(t)){let{secondarySignerAddresses:r}=t;return P({aptosConfig:n,sender:a,payload:e,options:o,secondarySignerAddresses:r,feePayerAddress:i})}return P({aptosConfig:n,sender:a,payload:e,options:o,feePayerAddress:i})}function _(t){return t.withFeePayer===!0}function B(t){return"secondarySignerAddresses"in t}function Y(t){let{transaction:e}=t;return h(e)}function R(t){let{signer:e,transaction:n}=t;return e.signTransactionWithAuthenticator(n)}function x(t){let{signer:e,transaction:n}=t;if(!n.feePayerAddress)throw new Error(`Transaction ${n} is not a Fee Payer transaction`);return n.feePayerAddress=e.accountAddress,R({signer:e,transaction:n})}async function nn(t){let{aptosConfig:e,transaction:n,signerPublicKey:a,secondarySignersPublicKeys:o,feePayerPublicKey:i,options:r}=t,u=C({transaction:n,signerPublicKey:a,secondarySignersPublicKeys:o,feePayerPublicKey:i,options:r}),{data:g}=await d({aptosConfig:e,body:u,path:"transactions/simulate",params:{estimate_gas_unit_price:t.options?.estimateGasUnitPrice??!1,estimate_max_gas_amount:t.options?.estimateMaxGasAmount??!1,estimate_prioritized_gas_unit_price:t.options?.estimatePrioritizedGasUnitPrice??!1},originMethod:"simulateTransaction",contentType:"application/x.aptos.signed_transaction+bcs"});return g}async function F(t){let{aptosConfig:e}=t,n=b({...t}),{data:a}=await d({aptosConfig:e,body:n,path:"transactions",originMethod:"submitTransaction",contentType:"application/x.aptos.signed_transaction+bcs"});return a}async function M(t){let{aptosConfig:e,signer:n,feePayer:a,transaction:o}=t;(n instanceof A||n instanceof f)&&await n.waitForProofFetch(),(a instanceof A||a instanceof f)&&await a.waitForProofFetch();let i=t.feePayerAuthenticator||a&&x({signer:a,transaction:o}),r=R({signer:n,transaction:o});return F({aptosConfig:e,transaction:o,senderAuthenticator:r,feePayerAuthenticator:i})}async function tn(t){let{aptosConfig:e,senderAuthenticator:n,feePayer:a,transaction:o}=t;(a instanceof A||a instanceof f)&&await a.waitForProofFetch();let i=x({signer:a,transaction:o});return F({aptosConfig:e,transaction:o,senderAuthenticator:n,feePayerAuthenticator:i})}var v={typeParameters:[],parameters:[c.u8(),new c(c.u8())]};async function en(t){let{aptosConfig:e,account:n,metadataBytes:a,moduleBytecode:o,options:i}=t,r=o.map(u=>s.U8(u));return S({aptosConfig:e,sender:p.from(n),data:{function:"0x1::code::publish_package_txn",functionArguments:[s.U8(a),new s(r)],abi:v},options:i})}var N={typeParameters:[],parameters:[new T,c.u8(),new T,c.u8(),c.u8(),c.u8()]};async function an(t){let{aptosConfig:e,fromAccount:n,toNewPrivateKey:a}=t,o=await I({aptosConfig:e,accountAddress:n.accountAddress}),i=w.fromPrivateKey({privateKey:a,legacy:!0}),u=new l({sequenceNumber:BigInt(o.sequence_number),originator:n.accountAddress,currentAuthKey:p.from(o.authentication_key),newPublicKey:i.publicKey}).bcsToBytes(),g=n.sign(u),D=i.sign(u),G=await S({aptosConfig:e,sender:n.accountAddress,data:{function:"0x1::account::rotate_authentication_key",functionArguments:[new m(n.signingScheme),s.U8(n.publicKey.toUint8Array()),new m(i.signingScheme),s.U8(i.publicKey.toUint8Array()),s.U8(g.toUint8Array()),s.U8(D.toUint8Array())],abi:N}});return M({aptosConfig:e,signer:n,transaction:G})}export{S as a,K as b,U as c,Y as d,R as e,x as f,nn as g,F as h,M as i,tn as j,en as k,an as l};
-//# sourceMappingURL=chunk-P2EIZ7WL.mjs.map
+import{a as y,f as P,g as C,i as b}from"./chunk-HGVZ7ULA.mjs";import{a as I}from"./chunk-7D3RY73L.mjs";import{a as f}from"./chunk-ZS3EWM5A.mjs";import{a as w}from"./chunk-HCV3NGLS.mjs";import{a as A}from"./chunk-5ZBHIUWG.mjs";import{d as h}from"./chunk-VQTEGTUQ.mjs";import{a as l}from"./chunk-5AAFF2PV.mjs";import{c as T,m as c}from"./chunk-OTY3NO7Q.mjs";import{b as d}from"./chunk-WOOH5MMX.mjs";import{a as s}from"./chunk-IECDO22V.mjs";import{b as m}from"./chunk-6FLHGOKP.mjs";import{b as p}from"./chunk-KM6UXNC7.mjs";async function S(t){let e=await K(t);return U(t,e)}async function K(t){let{aptosConfig:e,data:n}=t,a,o;return"bytecode"in n?o=await y(n):"multisigAddress"in n?(a={aptosConfig:e,multisigAddress:n.multisigAddress,function:n.function,functionArguments:n.functionArguments,typeArguments:n.typeArguments,abi:n.abi},o=await y(a)):(a={aptosConfig:e,function:n.function,functionArguments:n.functionArguments,typeArguments:n.typeArguments,abi:n.abi},o=await y(a)),o}async function U(t,e){let{aptosConfig:n,sender:a,options:o}=t,i;if(_(t)&&(i=p.ZERO.toString()),B(t)){let{secondarySignerAddresses:r}=t;return P({aptosConfig:n,sender:a,payload:e,options:o,secondarySignerAddresses:r,feePayerAddress:i})}return P({aptosConfig:n,sender:a,payload:e,options:o,feePayerAddress:i})}function _(t){return t.withFeePayer===!0}function B(t){return"secondarySignerAddresses"in t}function Y(t){let{transaction:e}=t;return h(e)}function R(t){let{signer:e,transaction:n}=t;return e.signTransactionWithAuthenticator(n)}function x(t){let{signer:e,transaction:n}=t;if(!n.feePayerAddress)throw new Error(`Transaction ${n} is not a Fee Payer transaction`);return n.feePayerAddress=e.accountAddress,R({signer:e,transaction:n})}async function nn(t){let{aptosConfig:e,transaction:n,signerPublicKey:a,secondarySignersPublicKeys:o,feePayerPublicKey:i,options:r}=t,u=C({transaction:n,signerPublicKey:a,secondarySignersPublicKeys:o,feePayerPublicKey:i,options:r}),{data:g}=await d({aptosConfig:e,body:u,path:"transactions/simulate",params:{estimate_gas_unit_price:t.options?.estimateGasUnitPrice??!1,estimate_max_gas_amount:t.options?.estimateMaxGasAmount??!1,estimate_prioritized_gas_unit_price:t.options?.estimatePrioritizedGasUnitPrice??!1},originMethod:"simulateTransaction",contentType:"application/x.aptos.signed_transaction+bcs"});return g}async function F(t){let{aptosConfig:e}=t,n=b({...t}),{data:a}=await d({aptosConfig:e,body:n,path:"transactions",originMethod:"submitTransaction",contentType:"application/x.aptos.signed_transaction+bcs"});return a}async function M(t){let{aptosConfig:e,signer:n,feePayer:a,transaction:o}=t;(n instanceof A||n instanceof f)&&await n.waitForProofFetch(),(a instanceof A||a instanceof f)&&await a.waitForProofFetch();let i=t.feePayerAuthenticator||a&&x({signer:a,transaction:o}),r=R({signer:n,transaction:o});return F({aptosConfig:e,transaction:o,senderAuthenticator:r,feePayerAuthenticator:i})}async function tn(t){let{aptosConfig:e,senderAuthenticator:n,feePayer:a,transaction:o}=t;(a instanceof A||a instanceof f)&&await a.waitForProofFetch();let i=x({signer:a,transaction:o});return F({aptosConfig:e,transaction:o,senderAuthenticator:n,feePayerAuthenticator:i})}var v={typeParameters:[],parameters:[c.u8(),new c(c.u8())]};async function en(t){let{aptosConfig:e,account:n,metadataBytes:a,moduleBytecode:o,options:i}=t,r=o.map(u=>s.U8(u));return S({aptosConfig:e,sender:p.from(n),data:{function:"0x1::code::publish_package_txn",functionArguments:[s.U8(a),new s(r)],abi:v},options:i})}var N={typeParameters:[],parameters:[new T,c.u8(),new T,c.u8(),c.u8(),c.u8()]};async function an(t){let{aptosConfig:e,fromAccount:n,toNewPrivateKey:a}=t,o=await I({aptosConfig:e,accountAddress:n.accountAddress}),i=w.fromPrivateKey({privateKey:a,legacy:!0}),u=new l({sequenceNumber:BigInt(o.sequence_number),originator:n.accountAddress,currentAuthKey:p.from(o.authentication_key),newPublicKey:i.publicKey}).bcsToBytes(),g=n.sign(u),D=i.sign(u),G=await S({aptosConfig:e,sender:n.accountAddress,data:{function:"0x1::account::rotate_authentication_key",functionArguments:[new m(n.signingScheme),s.U8(n.publicKey.toUint8Array()),new m(i.signingScheme),s.U8(i.publicKey.toUint8Array()),s.U8(g.toUint8Array()),s.U8(D.toUint8Array())],abi:N}});return M({aptosConfig:e,signer:n,transaction:G})}export{S as a,K as b,U as c,Y as d,R as e,x as f,nn as g,F as h,M as i,tn as j,en as k,an as l};
+//# sourceMappingURL=chunk-2I56E4T2.mjs.map