@aptos-labs/ts-sdk 1.29.0-zeta.0 → 1.29.0-zeta.2

package/src/transactions/management/transactionWorker.ts

@@ -13,8 +13,9 @@ import { SimpleTransaction } from "../instances/simpleTransaction";
 
 export const promiseFulfilledStatus = "fulfilled";
 
-// Event types the worker fires during execution and
-// the dapp can listen to
+/**
+ * Events emitted by the transaction worker during its operation, allowing the dapp to respond to various transaction states.
+ */
 export enum TransactionWorkerEventsEnum {
   // fired after a transaction gets sent to the chain
   TransactionSent = "transactionSent",
@@ -28,7 +29,14 @@ export enum TransactionWorkerEventsEnum {
   ExecutionFinish = "executionFinish",
 }
 
-// Typed interface of the worker events
+/**
+ * Defines the events emitted by the transaction worker during various stages of transaction processing. *
+ * @event transactionSent - Emitted when a transaction is successfully sent.
+ * @event transactionSendFailed - Emitted when sending a transaction fails.
+ * @event transactionExecuted - Emitted when a transaction is successfully executed.
+ * @event transactionExecutionFailed - Emitted when executing a transaction fails.
+ * @event executionFinish - Emitted when the execution process is finished.
+ */
 export interface TransactionWorkerEvents {
   transactionSent: (data: SuccessEventData) => void;
   transactionSendFailed: (data: FailureEventData) => void;
@@ -37,18 +45,24 @@ export interface TransactionWorkerEvents {
   executionFinish: (data: ExecutionFinishEventData) => void;
 }
 
-// Type for when the worker has finished its job
+/**
+ * The payload for when the worker has finished its job.
+ */
 export type ExecutionFinishEventData = {
   message: string;
 };
 
-// Type for a success event
+/**
+ * The payload for a success event.
+ */
 export type SuccessEventData = {
   message: string;
   transactionHash: string;
 };
 
-// Type for a failure event
+/**
+ * The payload for a failure event.
+ */
 export type FailureEventData = {
   message: string;
   error: string;
@@ -72,6 +86,7 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   readonly account: Account;
 
   // current account sequence number
+  // TODO: Rename Sequnce -> Sequence
   readonly accountSequnceNumber: AccountSequenceNumber;
 
   readonly taskQueue: AsyncQueue<() => Promise<void>> = new AsyncQueue<() => Promise<void>>();
@@ -104,15 +119,15 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   executedTransactions: Array<[string, bigint, any]> = [];
 
   /**
-   * Provides a simple framework for receiving payloads to be processed.
+   * Initializes a new instance of the class, providing a framework for receiving payloads to be processed.
    *
-   * @param aptosConfig - a config object
-   * @param sender - a sender as Account
-   * @param maxWaitTime - the max wait time to wait before resyncing the sequence number
-   * to the current on-chain state, default to 30
-   * @param maximumInFlight - submit up to `maximumInFlight` transactions per account.
-   * Mempool limits the number of transactions per account to 100, hence why we default to 100.
-   * @param sleepTime - If `maximumInFlight` are in flight, wait `sleepTime` seconds before re-evaluating, default to 10
+   * @param aptosConfig - A configuration object for Aptos.
+   * @param account - The account that will be used for sending transactions.
+   * @param maxWaitTime - The maximum wait time to wait before re-syncing the sequence number to the current on-chain state,
+   * default is 30 seconds.
+   * @param maximumInFlight - The maximum number of transactions that can be submitted per account, default is 100.
+   * @param sleepTime - The time to wait in seconds before re-evaluating if the maximum number of transactions are in flight,
+   * default is 10 seconds.
    */
   constructor(
     aptosConfig: AptosConfig,
@@ -135,10 +150,11 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Gets the current account sequence number,
-   * generates the transaction with the account sequence number,
-   * adds the transaction to the outstanding transaction queue
-   * to be processed later.
+   * Submits the next transaction for the account by generating it with the current sequence number
+   * and adding it to the outstanding transaction queue for processing.
+   * This function continues to submit transactions until there are no more to process.
+   *
+   * @throws {Error} Throws an error if the transaction submission fails.
    */
   async submitNextTransaction() {
     try {
@@ -164,13 +180,15 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Reads the outstanding transaction queue and submits the transaction to chain.
-   *
-   * If the transaction has fulfilled, it pushes the transaction to the processed
-   * transactions queue and fires a transactionsFulfilled event.
+   * Reads the outstanding transaction queue and submits the transactions to the chain.
+   * This function processes each transaction, checking their status and emitting events based on whether they were successfully
+   * sent or failed.
    *
-   * If the transaction has failed, it pushes the transaction to the processed
-   * transactions queue with the failure reason and fires a transactionsFailed event.
+   * @throws {Error} Throws an error if the process execution fails.
+   * @event TransactionWorkerEventsEnum.TransactionSent - Emitted when a transaction has been successfully committed to the chain.
+   * @event TransactionWorkerEventsEnum.TransactionSendFailed - Emitted when a transaction fails to commit, along with the error
+   * reason.
+   * @event TransactionWorkerEventsEnum.ExecutionFinish - Emitted when the execution of transactions is complete.
    */
   async processTransactions() {
     try {
@@ -226,9 +244,9 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Once transaction has been sent to chain, we check for its execution status.
-   * @param sentTransaction transactions that were sent to chain and are now waiting to be executed
-   * @param sequenceNumber the account's sequence number that was sent with the transaction
+   * Once a transaction has been sent to the chain, this function checks for its execution status.
+   * @param sentTransaction - The transaction that was sent to the chain and is now waiting to be executed.
+   * @param sequenceNumber - The account's sequence number that was sent with the transaction.
    */
   async checkTransaction(sentTransaction: PromiseFulfilledResult<PendingTransactionResponse>, sequenceNumber: bigint) {
     try {
@@ -260,14 +278,15 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Push transaction to the transactions queue
+   * Pushes a transaction to the transactions queue for processing.
    *
-   * @param transactionData Transaction payload
-   * @param transactionData.abi For all entry function payloads, the ABI to skip remote ABI lookups
-   * @param options.maxGasAmount Maximum gas amount for the transaction
-   * @param options.gasUnitPrice Gas unit price for the transaction
-   * @param options.expireTimestamp expiration timestamp on the transaction
-   * @param options.accountSequenceNumber the sequence number for the transaction
+   * @param transactionData - The transaction payload containing necessary details.
+   * @param transactionData.abi - For all entry function payloads, the ABI to skip remote ABI lookups.
+   * @param options - Optional parameters for transaction configuration.
+   * @param options.maxGasAmount - Maximum gas amount for the transaction.
+   * @param options.gasUnitPrice - Gas unit price for the transaction.
+   * @param options.expireTimestamp - Expiration timestamp on the transaction.
+   * @param options.accountSequenceNumber - The sequence number for the transaction.
    */
   async push(
     transactionData: InputGenerateTransactionPayloadData,
@@ -277,10 +296,11 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Generates a signed transaction that can be submitted to chain
-   * @param account an Aptos account
-   * @param sequenceNumber a sequence number the transaction will be generated with
-   * @returns
+   * Generates a signed transaction that can be submitted to the chain.
+   *
+   * @param account - An Aptos account used as the sender of the transaction.
+   * @param sequenceNumber - A sequence number the transaction will be generated with.
+   * @returns A signed transaction object or undefined if the transaction queue is empty.
    */
   async generateNextTransaction(account: Account, sequenceNumber: bigint): Promise<SimpleTransaction | undefined> {
     if (this.transactionsQueue.isEmpty()) return undefined;
@@ -294,7 +314,9 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Starts transaction submission and transaction processing.
+   * Starts transaction submission and processing by executing tasks from the queue until it is cancelled.
+   *
+   * @throws {Error} Throws an error if unable to start transaction batching.
    */
   async run() {
     try {
@@ -309,6 +331,8 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
 
   /**
    * Starts the transaction management process.
+   *
+   * @throws {Error} Throws an error if the worker has already started.
    */
   start() {
     if (this.started) {
@@ -321,7 +345,9 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
   }
 
   /**
-   * Stops the the transaction management process.
+   * Stops the transaction management process.
+   *
+   * @throws {Error} Throws an error if the worker has already stopped.
    */
   stop() {
     if (this.taskQueue.isCancelled()) {

package/src/transactions/transactionBuilder/helpers.ts

@@ -12,18 +12,45 @@ import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256,
 import { AccountAddress } from "../../core";
 import { MoveFunction, MoveFunctionId } from "../../types";
 
+/**
+ * Determines if the provided argument is of type boolean.
+ * This can help in validating input types before processing them further.
+ *
+ * @param arg - The argument to check, which can be of various types.
+ * @returns A boolean indicating whether the argument is a boolean.
+ */
 export function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {
   return typeof arg === "boolean";
 }
 
+/**
+ * Checks if the provided argument is of type string.
+ *
+ * @param arg - The value to be checked for string type.
+ * @returns A boolean indicating whether the argument is a string.
+ */
 export function isString(arg: any): arg is string {
   return typeof arg === "string";
 }
 
+/**
+ * Determines if the provided argument is of type number.
+ *
+ * @param arg - The argument to check, which can be of various types.
+ * @returns A boolean indicating whether the argument is a number.
+ */
 export function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {
   return typeof arg === "number";
 }
 
+/**
+ * Converts a number or a string representation of a number into a number type.
+ * This function is useful for ensuring that the input is in a consistent numeric format,
+ * which can help prevent type mismatches in further processing.
+ *
+ * @param arg - The input value to be converted. This can be a number, a string representing a number, or any other type.
+ * @returns Returns the converted number if the input is valid; otherwise, it returns undefined.
+ */
 export function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | undefined {
   if (isNumber(arg)) {
     return arg;
@@ -35,27 +62,101 @@ export function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | u
   return undefined;
 }
 
+/**
+ * Determines if the provided argument is a large number, which can be a number, bigint, or string representation of a number.
+ *
+ * @param arg - The argument to check, which can be of type number, bigint, or string.
+ */
 export function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string {
   return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
 }
 
+/**
+ * Checks if the provided argument is empty, meaning it is either null or undefined.
+ *
+ * @param arg - The argument to check for emptiness.
+ * @returns A boolean indicating whether the argument is empty.
+ */
 export function isEmptyOption(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined {
   return arg === null || arg === undefined;
 }
 
+/**
+ * Determines if the provided argument is a valid encoded entry function argument type.
+ * This function helps validate that the argument conforms to the expected types for entry function parameters.
+ *
+ * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+ */
 export function isEncodedEntryFunctionArgument(
   arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
 ): arg is EntryFunctionArgumentTypes {
   return (
+    /**
+     * Determines if the provided argument is an instance of the Bool class.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsBool(arg) ||
+    /**
+     * Determines if the provided argument is an instance of U8.
+     * This function helps validate the type of the argument passed to ensure it is a U8 type.
+     *
+     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsU8(arg) ||
+    /**
+     * Determines if the provided argument is an instance of U16.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsU16(arg) ||
+    /**
+     * Determines if the provided argument is an instance of U32.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @returns A boolean indicating whether the argument is a U32 instance.
+     */
     isBcsU32(arg) ||
+    /**
+     * Determine if the provided argument is an instance of U64.
+     * This function helps validate that the argument conforms to the expected U64 type.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsU64(arg) ||
+    /**
+     * Determines if the provided argument is an instance of U128.
+     * This function helps validate the type of the argument passed to ensure it is a U128 type.
+     *
+     * @param arg - The argument to be checked, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsU128(arg) ||
+    /**
+     * Determines if the provided argument is an instance of U256.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     * @returns A boolean indicating whether the argument is a U256 instance.
+     */
     isBcsU256(arg) ||
+    /**
+     * Determines if the provided argument is an instance of AccountAddress.
+     * This function helps validate whether a given input corresponds to a valid BCS address type.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsAddress(arg) ||
+    /**
+     * Determine if the provided argument is an instance of MoveString.
+     *
+     * @param arg - The argument to check, which can be of types EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsString(arg) ||
+    /**
+     * Determine if the provided argument is an instance of FixedBytes.
+     * This function helps to validate the type of the argument being passed.
+     *
+     * @param arg - The argument to check, which can be of type EntryFunctionArgumentTypes or SimpleEntryFunctionArgumentTypes.
+     */
     isBcsFixedBytes(arg) ||
     arg instanceof MoveVector ||
     arg instanceof MoveOption
@@ -104,22 +205,40 @@ export function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionA
   return arg instanceof U256;
 }
 
+/**
+ * Determines if the provided argument contains script data input by checking for the presence of bytecode.
+ *
+ * @param arg - The input data to be checked, which can either be a payload with remote ABI or a standard payload.
+ * @param arg.bytecode - The bytecode of the script, present if the input is script data.
+ * @param arg.function - The function associated with the transaction, which is relevant for standard payloads.
+ * @param arg.args - The arguments for the function, applicable in the context of standard payloads.
+ */
 export function isScriptDataInput(
   arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData,
 ): arg is InputScriptData {
   return "bytecode" in arg;
 }
 
+/**
+ * Throws an error indicating a type mismatch for a specified argument position.
+ * This function helps in debugging by providing clear feedback on expected types.
+ *
+ * @param expectedType - The type that was expected for the argument.
+ * @param position - The position of the argument that caused the type mismatch.
+ */
 export function throwTypeMismatch(expectedType: string, position: number) {
   throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
 }
 
 /**
- * Finds first non-signer arg.
+ * Finds the index of the first non-signer argument in the function ABI parameters.
  *
  * A function is often defined with a `signer` or `&signer` arguments at the start, which are filled in
- * by signatures, and not by the caller.
- * @param functionAbi
+ * by signatures and not by the caller. This function helps identify the position of the first argument that
+ * can be provided by the caller, allowing for easier handling of function parameters.
+ *
+ * @param functionAbi - The ABI of the function to analyze.
+ * @returns The index of the first non-signer argument, or the length of the parameters array if none are found.
  */
 export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
@@ -129,6 +248,14 @@ export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   return index;
 }
 
+/**
+ * Splits a function identifier into its constituent parts: module address, module name, and function name.
+ * This function helps in validating and extracting details from a function identifier string.
+ *
+ * @param functionArg - The function identifier string in the format "moduleAddress::moduleName::functionName".
+ * @returns An object containing the module address, module name, and function name.
+ * @throws Error if the function identifier does not contain exactly three parts.
+ */
 export function getFunctionParts(functionArg: MoveFunctionId) {
   const funcNameParts = functionArg.split("::");
   if (funcNameParts.length !== 3) {

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -50,7 +50,10 @@ import { MoveFunction } from "../../types";
 const TEXT_ENCODER = new TextEncoder();
 
 /**
- * Convert type arguments to only type tags, allowing for string representations of type tags
+ * Convert type arguments to only type tags, allowing for string representations of type tags.
+ *
+ * @param typeArguments - An optional array of type arguments that may include string representations.
+ * @returns An array of TypeTag objects derived from the provided type arguments.
  */
 export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag> {
   return (
@@ -65,11 +68,13 @@ export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<
 }
 
 /**
- * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
- * @param moduleAddress
- * @param moduleName
- * @param functionName
- * @param aptosConfig
+ * Fetches the ABI of a specified function from the on-chain module ABI. This function allows you to access the details of a
+ * specific function within a module.
+ *
+ * @param moduleAddress - The address of the module from which to fetch the function ABI.
+ * @param moduleName - The name of the module containing the function.
+ * @param functionName - The name of the function whose ABI is to be fetched.
+ * @param aptosConfig - The configuration settings for Aptos.
  */
 export async function fetchFunctionAbi(
   moduleAddress: string,
@@ -88,12 +93,15 @@ export async function fetchFunctionAbi(
 }
 
 /**
- * Fetches the ABI for an entry function from the module
+ * Fetches the ABI for an entry function from the specified module address.
+ * This function validates if the ABI corresponds to an entry function and retrieves its parameters.
  *
- * @param moduleAddress
- * @param moduleName
- * @param functionName
- * @param aptosConfig
+ * @param moduleAddress - The address of the module containing the entry function.
+ * @param moduleName - The name of the module containing the entry function.
+ * @param functionName - The name of the entry function to fetch the ABI for.
+ * @param aptosConfig - The configuration settings for Aptos.
+ * @returns An object containing the number of signers, type parameters, and function parameters.
+ * @throws Error if the ABI cannot be found or if the function is not an entry function.
  */
 export async function fetchEntryFunctionAbi(
   moduleAddress: string,
@@ -128,12 +136,15 @@ export async function fetchEntryFunctionAbi(
 }
 
 /**
- * Fetches the ABI for a view function from the module
+ * Fetches the ABI for a view function from the specified module address.
+ * This function ensures that the ABI is valid and retrieves the type parameters, parameters, and return types for the view function.
  *
- * @param moduleAddress
- * @param moduleName
- * @param functionName
- * @param aptosConfig
+ * @param moduleAddress - The address of the module containing the view function.
+ * @param moduleName - The name of the module containing the view function.
+ * @param functionName - The name of the view function for which to fetch the ABI.
+ * @param aptosConfig - The configuration settings for Aptos.
+ * @returns An object containing the type parameters, parameters, and return types of the view function.
+ * @throws Error if the ABI cannot be found or if the function is not a view function.
  */
 export async function fetchViewFunctionAbi(
   moduleAddress: string,
@@ -173,12 +184,14 @@ export async function fetchViewFunctionAbi(
 }
 
 /**
- * Converts a non-BCS encoded argument into BCS encoded, if necessary
- * @param functionName
- * @param functionAbi
- * @param arg
- * @param position
- * @param genericTypeParams
+ * Converts a non-BCS encoded argument into BCS encoded, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param arg - The argument to be converted, which can be of various types.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
  */
 export function convertArgument(
   functionName: string,
@@ -196,6 +209,15 @@ export function convertArgument(
   return checkOrConvertArgument(arg, param, position, genericTypeParams);
 }
 
+/**
+ * Checks if the provided argument is BCS encoded and converts it if necessary, ensuring type compatibility with the ABI.
+ * This function helps in validating and converting arguments for entry functions based on their expected types.
+ *
+ * @param arg - The argument to check or convert, which can be either a simple or entry function argument type.
+ * @param param - The expected type tag for the argument.
+ * @param position - The position of the argument in the function call.
+ * @param genericTypeParams - An array of generic type parameters that may be used for conversion.
+ */
 export function checkOrConvertArgument(
   arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes,
   param: TypeTag,
@@ -205,6 +227,15 @@ export function checkOrConvertArgument(
   // If the argument is bcs encoded, we can just use it directly
   if (isEncodedEntryFunctionArgument(arg)) {
     // Ensure the type matches the ABI
+
+    /**
+     * Checks the type of the provided argument against the expected type.
+     * This function helps validate that the argument conforms to the specified type requirements.
+     *
+     * @param typeArgs - The expected type arguments.
+     * @param arg - The argument to be checked.
+     * @param position - The position of the argument in the context of the check.
+     */
     checkType(param, arg, position);
     return arg;
   }
@@ -214,11 +245,14 @@ export function checkOrConvertArgument(
 }
 
 /**
- * Parses a non-BCS encoded argument into a BCS encoded argument recursively
- * @param arg
- * @param param
- * @param position
- * @param genericTypeParams
+ * Parses a non-BCS encoded argument into a BCS encoded argument recursively.
+ * This function helps convert various types of input arguments into their corresponding BCS encoded formats based on the
+ * specified parameter type.
+ *
+ * @param arg - The argument to be parsed, which can be of various types.
+ * @param param - The type tag that defines the expected type of the argument.
+ * @param position - The position of the argument in the function call, used for error reporting.
+ * @param genericTypeParams - An array of type tags for generic type parameters, used when the parameter type is generic.
  */
 function parseArg(
   arg: SimpleEntryFunctionArgumentTypes,
@@ -234,6 +268,13 @@ function parseArg(
       if (arg === "true") return new Bool(true);
       if (arg === "false") return new Bool(false);
     }
+
+    /**
+     * Throws a type mismatch error for the specified move option.
+     *
+     * @param moveOption - The name of the move option that caused the type mismatch.
+     * @param position - The position where the error occurred.
+     */
     throwTypeMismatch("boolean", position);
   }
   // TODO: support uint8array?
@@ -283,7 +324,7 @@ function parseArg(
     throwTypeMismatch("bigint | number | string", position);
   }
 
-  // Generic needs to use the sub-type
+  // Generic needs to use the subtype
   if (param.isGeneric()) {
     const genericIndex = param.value;
     if (genericIndex < 0 || genericIndex >= genericTypeParams.length) {
@@ -297,7 +338,7 @@ function parseArg(
   if (param.isVector()) {
     // Check special case for Vector<u8>
     if (param.value.isU8()) {
-      // We don't allow vector<u8>, but we convert strings to UTF8 uint8array
+      // We don't allow vector<u8>, but we convert strings to UTF8 Uint8Array
       // This is legacy behavior from the original SDK
       if (isString(arg)) {
         return MoveVector.U8(TEXT_ENCODER.encode(arg));
@@ -380,7 +421,7 @@ function parseArg(
 }
 
 /**
- * Checks that the type of an already BCS encoded argument matches the ABI
+ * Checks that the type of the BCS encoded argument matches the ABI
  * @param param
  * @param arg
  * @param position

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -11,9 +11,14 @@ import { AnyRawTransaction, AnyRawTransactionInstance } from "../types";
 import { Serializable } from "../../bcs";
 
 /**
- * Derive the raw transaction type - FeePayerRawTransaction or MultiAgentRawTransaction or RawTransaction
+ * Derives the appropriate raw transaction type based on the provided transaction details.
+ * This function helps in identifying whether the transaction is a FeePayerRawTransaction,
+ * MultiAgentRawTransaction, or a standard RawTransaction.
  *
- * @param transaction A aptos transaction type
+ * @param transaction - An object representing an Aptos transaction, which may include:
+ *   - feePayerAddress - The address of the fee payer (optional).
+ *   - secondarySignerAddresses - An array of secondary signer addresses (optional).
+ *   - rawTransaction - The raw transaction data.
  *
  * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
  */
@@ -34,11 +39,12 @@ export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTra
 
 /**
  * Generates the 'signing message' form of a message to be signed.
+ * This function combines a domain separator with the byte representation of the message to create a signing message.
  *
- * @param bytes The byte representation of the message to be signed and sent to the chain
- * @param domainSeparator A domain separator that starts with 'APTOS::'
+ * @param bytes - The byte representation of the message to be signed and sent to the chain.
+ * @param domainSeparator - A domain separator that starts with 'APTOS::'.
  *
- * @returns The Uint8Array of the signing message
+ * @returns The Uint8Array of the signing message.
  */
 export function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {
   const hash = sha3Hash.create();
@@ -64,25 +70,24 @@ export function generateSigningMessage(bytes: Uint8Array, domainSeparator: strin
  * @deprecated
  * Use CryptoHashable instead by having your class implement it and call hash() to get the signing message.
  *
- * Generates the 'signing message' form of a serilizable value. It bcs serializes the value and uses the name of
- * its constructor as the domain separator.
+ * Generates the 'signing message' form of a serializable value by serializing it and using the constructor name as the domain
+ * separator.
  *
- * @param serializable An object that has a bcs serialized form
+ * @param serializable - An object that has a BCS serialized form.
  *
- * @returns The Uint8Array of the signing message
+ * @returns The Uint8Array of the signing message.
  */
 export function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array {
   return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);
 }
 
 /**
- * Generates the 'signing message' form of a transaction. It derives the type of transaction and
- * applies the appropriate domain separator based on if there is extra data such as a fee payer or
- * secondary signers.
+ * Generates the 'signing message' form of a transaction by deriving the type of transaction and applying the appropriate domain
+ * separator based on the presence of a fee payer or secondary signers.
  *
- * @param transaction A transaction that is to be signed
+ * @param transaction - A transaction that is to be signed, which can include a fee payer address or secondary signer addresses.
  *
- * @returns The Uint8Array of the signing message
+ * @returns The Uint8Array of the signing message.
  */
 export function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {
   const rawTxn = deriveTransactionType(transaction);