@aptos-labs/ts-sdk 1.29.1 → 1.30.0

package/src/api/transactionSubmission/submit.ts

@@ -8,23 +8,80 @@ import { AptosConfig } from "../aptosConfig";
 import { ValidateFeePayerDataOnSubmission } from "./helpers";
 
 /**
- * A class to handle all `Submit` transaction operations
+ * A class to handle all `Submit` transaction operations.
  */
 export class Submit {
   readonly config: AptosConfig;
 
+  /**
+   * Initializes a new instance of the Aptos client with the specified configuration.
+   * This allows you to interact with the Aptos blockchain using the provided settings.
+   *
+   * @param config - The configuration settings for the Aptos client.
+   * @param config.network - The network to connect to (e.g., TESTNET, MAINNET).
+   * @param config.nodeUrl - The URL of the Aptos node to connect to.
+   * @param config.faucetUrl - The URL of the faucet for obtaining test tokens.
+   *
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+   *
+   * async function runExample() {
+   *     // Create a configuration for the Aptos client
+   *     const config = new AptosConfig({
+   *         network: Network.TESTNET, // Use the TESTNET for testing
+   *         nodeUrl: "https://testnet.aptos.dev", // Specify the node URL
+   *         faucetUrl: "https://faucet.testnet.aptos.dev" // Specify the faucet URL
+   *     });
+   *
+   *     // Initialize the Aptos client with the configuration
+   *     const aptos = new Aptos(config);
+   *
+   *     console.log("Aptos client initialized:", aptos);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   */
   constructor(config: AptosConfig) {
     this.config = config;
   }
 
   /**
-   * Submit a simple transaction
+   * Submits a transaction to the Aptos blockchain using the provided transaction details and authenticators.
+   * This function allows you to execute transactions securely by specifying the sender and optional fee payer authenticators.
+   *
+   * @param args - The arguments for submitting the transaction.
+   * @param args.transaction - The raw transaction data to be submitted.
+   * @param args.senderAuthenticator - The authenticator for the sender's account.
+   * @param [args.feePayerAuthenticator] - The optional authenticator for the fee payer's account.
    *
-   * @param args.transaction An instance of a raw transaction
-   * @param args.senderAuthenticator optional. The sender account authenticator
-   * @param args.feePayerAuthenticator optional. The fee payer account authenticator if it is a fee payer transaction
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
    *
-   * @returns PendingTransactionResponse
+   * const config = new AptosConfig({ network: Network.TESTNET });
+   * const aptos = new Aptos(config);
+   *
+   * async function runExample() {
+   *   const sender = Account.generate(); // Generate a new sender account
+   *   const transaction = await aptos.transaction.build.simple({
+   *     sender: sender.accountAddress,
+   *     data: {
+   *       function: "0x1::aptos_account::transfer",
+   *       functionArguments: [Account.generate().accountAddress, 100], // Replace with a real destination account
+   *     },
+   *   });
+   *
+   *   // Submit the transaction
+   *   const response = await aptos.simple({
+   *     transaction,
+   *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+   *   });
+   *
+   *   console.log("Transaction submitted:", response);
+   * }
+   * runExample().catch(console.error);
+   * ```
    */
   @ValidateFeePayerDataOnSubmission
   async simple(args: {
@@ -36,14 +93,48 @@ export class Submit {
   }
 
   /**
-   * Submit a multi agent transaction
+   * Submits a multi-agent transaction to the Aptos network, allowing multiple signers to authorize the transaction.
+   * This function is useful for scenarios where a transaction requires approval from multiple accounts.
+   *
+   * @param args - The parameters for the multi-agent transaction.
+   * @param args.transaction - The raw transaction to be submitted.
+   * @param args.senderAuthenticator - The authenticator for the sender account.
+   * @param args.additionalSignersAuthenticators - An array of authenticators for additional signers.
+   * @param [args.feePayerAuthenticator] - An optional authenticator for the fee payer account.
+   *
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network, Account } from "@aptos-labs/ts-sdk";
+   *
+   * const config = new AptosConfig({ network: Network.TESTNET });
+   * const aptos = new Aptos(config);
+   *
+   * async function runExample() {
+   *   const sender = Account.generate(); // Generate a new sender account
+   *   const additionalSigner1 = Account.generate(); // Generate an additional signer account
+   *   const additionalSigner2 = Account.generate(); // Generate another additional signer account
+   *
+   *   const transaction = await aptos.transaction.build.simple({
+   *     sender: sender.accountAddress,
+   *     data: {
+   *       function: "0x1::aptos_account::transfer",
+   *       functionArguments: [additionalSigner1.accountAddress, 100],
+   *     },
+   *   });
    *
-   * @param args.transaction An instance of a raw transaction
-   * @param args.senderAuthenticator optional. The sender account authenticator
-   * @param args.additionalSignersAuthenticators An array of the secondary signers account authenticators
-   * @param args.feePayerAuthenticator optional. The fee payer account authenticator if it is a fee payer transaction
+   *   const response = await aptos.multiAgent({
+   *     transaction,
+   *     senderAuthenticator: sender.getAuthenticator(), // Use the sender's authenticator
+   *     additionalSignersAuthenticators: [
+   *       additionalSigner1.getAuthenticator(), // Use the first additional signer's authenticator
+   *       additionalSigner2.getAuthenticator(), // Use the second additional signer's authenticator
+   *     ],
+   *   });
    *
-   * @returns PendingTransactionResponse
+   *   console.log(response); // Log the response from the transaction submission
+   * }
+   * runExample().catch(console.error);
+   * ```
    */
   @ValidateFeePayerDataOnSubmission
   async multiAgent(args: {

package/src/api/utils.ts

@@ -4,10 +4,33 @@ import { AptosConfig } from "./aptosConfig";
 import { AnyNumber } from "../types";
 
 /**
- * Utility function to handle optional waiting on indexer for APIs
+ * Waits for the indexer to reach a specified ledger version, allowing for synchronization with the blockchain.
+ * This function is useful for ensuring that your application is working with the most up-to-date data before proceeding.
  *
- * This is purposely placed here to not expose this internal function.
- * @param args
+ * @param args - The parameters for waiting on the indexer.
+ * @param args.config - The configuration object for Aptos.
+ * @param [args.minimumLedgerVersion] - The minimum ledger version to wait for. If not specified, the function will not wait.
+ * @param args.processorType - The type of processor to wait for.
+ *
+ * @example
+ * ```typescript
+ * import { Aptos, AptosConfig, Network, ProcessorType } from "@aptos-labs/ts-sdk";
+ *
+ * const config = new AptosConfig({ network: Network.TESTNET });
+ * const aptos = new Aptos(config);
+ *
+ * async function runExample() {
+ *   // Wait for the indexer to reach a specific ledger version
+ *   await aptos.waitForIndexerOnVersion({
+ *     config: config,
+ *     minimumLedgerVersion: 1000n, // replace with a real ledger version
+ *     processorType: ProcessorType.DEFAULT,
+ *   });
+ *
+ *   console.log("Indexer is synced to the specified ledger version.");
+ * }
+ * runExample().catch(console.error);
+ * ```
  */
 export async function waitForIndexerOnVersion(args: {
   config: AptosConfig;

package/src/bcs/deserializer.ts

@@ -10,16 +10,43 @@ import { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256 } from "../types";
  * 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.
  */
 export 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.
+ */
 export class Deserializer {
   private buffer: ArrayBuffer;
 
   private offset: number;
 
+  /**
+   * 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) {
     // copies data to prevent outside mutation of buffer.
     this.buffer = new ArrayBuffer(data.length);
@@ -27,6 +54,12 @@ export class Deserializer {
     this.offset = 0;
   }
 
+  /**
+   * 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(length: number): ArrayBuffer {
     if (this.offset + length > this.buffer.byteLength) {
       throw new Error("Reached to the end of buffer");
@@ -40,21 +73,23 @@ export class Deserializer {
   /**
    * 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 {
     return this.buffer.byteLength - this.offset;
   }
 
   /**
-   * 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");
    * ```
@@ -66,11 +101,12 @@ export class Deserializer {
   }
 
   /**
-   * 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]));
@@ -83,9 +119,9 @@ export class Deserializer {
   }
 
   /**
-   * 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]));
@@ -98,7 +134,7 @@ export 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 {
     const exists = this.deserializeBool();
@@ -108,8 +144,10 @@ export class Deserializer {
   /**
    * 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 {
     const len = this.deserializeUleb128AsU32();
@@ -117,17 +155,22 @@ export class Deserializer {
   }
 
   /**
-   * 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 {
     return new Uint8Array(this.read(len));
   }
 
   /**
-   * 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 {
     const bool = new Uint8Array(this.read(1))[0];
@@ -138,20 +181,22 @@ export class Deserializer {
   }
 
   /**
-   * 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 {
     return new DataView(this.read(1)).getUint8(0);
   }
 
   /**
-   * 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);
    * ```
@@ -161,11 +206,11 @@ export class Deserializer {
   }
 
   /**
-   * 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);
    * ```
@@ -177,9 +222,9 @@ export 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);
    * ```
@@ -193,9 +238,10 @@ export class Deserializer {
   }
 
   /**
-   * 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 {
     const low = this.deserializeU64();
@@ -206,9 +252,11 @@ export class Deserializer {
   }
 
   /**
-   * 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 {
     const low = this.deserializeU128();
@@ -221,7 +269,10 @@ export class Deserializer {
   /**
    * 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 {
     let value: bigint = BigInt(0);
@@ -264,10 +315,10 @@ export class Deserializer {
   }
 
   /**
-   * 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>(
@@ -284,7 +335,6 @@ export 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> {
     const length = this.deserializeUleb128AsU32();

package/src/bcs/serializable/entryFunctionBytes.ts

@@ -11,8 +11,7 @@ import { HexInput } from "../../types";
  * 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
@@ -21,6 +20,11 @@ import { HexInput } from "../../types";
 export class EntryFunctionBytes extends Serializable implements EntryFunctionArgument {
   public 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(value: HexInput) {
     super();
     this.value = new FixedBytes(value);
@@ -32,6 +36,16 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
   // In other words, this class is only used to represent a sequence of bytes that are already
   // BCS-serialized as a type. To represent those bytes accurately, the BCS-serialized form is the same exact
   // representation.
+
+  /**
+   * 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 {
     serializer.serialize(this.value);
   }
@@ -41,6 +55,14 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
   // byte vector to an `any` type.
   // NOTE: This, and the lack of a `serializeForScriptFunction`, is the only meaningful difference between this
   // class and FixedBytes.
+
+  /**
+   * 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 {
     serializer.serializeU32AsUleb128(this.value.value.length);
     serializer.serialize(this);
@@ -48,11 +70,10 @@ export class EntryFunctionBytes extends Serializable implements EntryFunctionArg
 
   /**
    * 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 {
     const fixedBytes = FixedBytes.deserialize(deserializer, length);

package/src/bcs/serializable/fixedBytes.ts

@@ -8,56 +8,86 @@ import { Hex } from "../../core/hex";
 import { TransactionArgument } from "../../transactions/instances/transactionArgument";
 
 /**
- *  This class exists to represent 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.
- *
- *  If you want to write your own serialization function and pass the bytes as a transaction argument,
- *  you should use this class.
- *
- *  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],
- *  });
- *
+ * Represents a contiguous sequence of already serialized BCS 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>.
+ * 
+ * An example use case includes handling 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],
+ * });
+ * 
+ * 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
  */
 export class FixedBytes extends Serializable implements TransactionArgument {
   public 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) {
     super();
     this.value = Hex.fromHexInput(value).toUint8Array();
   }
 
+  /**
+   * 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 {
     serializer.serializeFixedBytes(this.value);
   }
 
+  /**
+   * 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 {
     serializer.serialize(this);
   }
 
+  /**
+   * 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 {
     serializer.serialize(this);
   }
 
+  /**
+   * 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 {
     const bytes = deserializer.deserializeFixedBytes(length);
     return new FixedBytes(bytes);