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

package/src/internal/object.ts

@@ -6,6 +6,18 @@ import { GetObjectData } from "../types/generated/queries";
 import { CurrentObjectsBoolExp } from "../types/generated/types";
 import { queryIndexer } from "./general";
 
+/**
+ * Retrieves the current objects based on specified filtering and pagination options.
+ *
+ * @param args - The arguments for retrieving object data.
+ * @param args.aptosConfig - The configuration settings for Aptos.
+ * @param [args.options] - Optional parameters for pagination and filtering.
+ * @param [args.options.offset] - The number of items to skip before starting to collect the result set.
+ * @param [args.options.limit] - The maximum number of items to return.
+ * @param [args.options.orderBy] - The criteria for ordering the results.
+ * @param [args.options.where] - The conditions to filter the results.
+ * @returns The current objects that match the specified criteria.
+ */
 export async function getObjectData(args: {
   aptosConfig: AptosConfig;
   options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]> & WhereArg<CurrentObjectsBoolExp>;
@@ -30,6 +42,15 @@ export async function getObjectData(args: {
   return data.current_objects;
 }
 
+/**
+ * Retrieves the object data associated with a specific object address.
+ * This function allows you to access detailed information about an object in the Aptos blockchain.
+ *
+ * @param args - The arguments for retrieving object data.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.
+ * @param args.objectAddress - The address of the object whose data is being retrieved.
+ * @param args.options - Optional parameters for pagination and ordering of the results.
+ */
 export async function getObjectDataByObjectAddress(args: {
   aptosConfig: AptosConfig;
   objectAddress: AccountAddressInput;

package/src/internal/queries/getTableItemsData.graphql

@@ -12,4 +12,4 @@ query getTableItemsData(
     transaction_version
     write_set_change_index
   }
-}
+}

package/src/internal/queries/getTableItemsMetadata.graphql

@@ -9,4 +9,4 @@ query getTableItemsMetadata(
     key_type
     value_type
   }
-}
+}

package/src/internal/staking.ts

@@ -15,6 +15,14 @@ import { GetDelegatedStakingActivitiesQuery, GetNumberOfDelegatorsQuery } from "
 import { GetDelegatedStakingActivities, GetNumberOfDelegators } from "../types/generated/queries";
 import { queryIndexer } from "./general";
 
+/**
+ * Retrieves the number of active delegators for a specified pool address.
+ *
+ * @param args - The arguments for the function.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.poolAddress - The address of the pool for which to retrieve the number of delegators.
+ * @returns The number of active delegators for the specified pool address.
+ */
 export async function getNumberOfDelegators(args: {
   aptosConfig: AptosConfig;
   poolAddress: AccountAddressInput;
@@ -27,11 +35,20 @@ export async function getNumberOfDelegators(args: {
   };
   const data = await queryIndexer<GetNumberOfDelegatorsQuery>({ aptosConfig, query });
 
-  // commonjs (aka cjs) doesnt handle Nullish Coalescing for some reason
+  // commonjs (aka cjs) doesn't handle Nullish Coalescing for some reason
   // might be because of how ts infer the graphql generated scheme type
   return data.num_active_delegator_per_pool[0] ? data.num_active_delegator_per_pool[0].num_active_delegator : 0;
 }
 
+/**
+ * Retrieves the number of active delegators for all pools.
+ *
+ * @param args - The arguments for the function.
+ * @param args.aptosConfig - The configuration for the Aptos client.
+ * @param [args.options] - Optional parameters for ordering the results.
+ * @param args.options.orderBy - Specifies the order in which to return the results.
+ * @returns The number of active delegators per pool.
+ */
 export async function getNumberOfDelegatorsForAllPools(args: {
   aptosConfig: AptosConfig;
   options?: OrderByArg<GetNumberOfDelegatorsResponse[0]>;
@@ -48,6 +65,15 @@ export async function getNumberOfDelegatorsForAllPools(args: {
   return data.num_active_delegator_per_pool;
 }
 
+/**
+ * Retrieves the delegated staking activities for a specified delegator and pool.
+ *
+ * @param args - The parameters for the query.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.delegatorAddress - The address of the delegator whose activities are being queried.
+ * @param args.poolAddress - The address of the pool associated with the delegated staking activities.
+ * @returns The delegated staking activities for the specified delegator and pool.
+ */
 export async function getDelegatedStakingActivities(args: {
   aptosConfig: AptosConfig;
   delegatorAddress: AccountAddressInput;

package/src/internal/table.ts

@@ -14,6 +14,15 @@ import { GetTableItemsData, GetTableItemsMetadata } from "../types/generated/que
 import { TableItemsBoolExp, TableMetadatasBoolExp } from "../types/generated/types";
 import { queryIndexer } from "./general";
 
+/**
+ * Retrieves a specific item from a table in the Aptos blockchain.
+ *
+ * @param args - The arguments for retrieving the table item.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.
+ * @param args.handle - The identifier for the table from which to retrieve the item.
+ * @param args.data - The request data for the table item.
+ * @param args.options - Optional parameters for the request, including ledger version.
+ */
 export async function getTableItem<T>(args: {
   aptosConfig: AptosConfig;
   handle: string;
@@ -31,6 +40,17 @@ export async function getTableItem<T>(args: {
   return response.data as T;
 }
 
+/**
+ * Retrieves table items data based on specified conditions and pagination options.
+ *
+ * @param args - The arguments for retrieving table items data.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.options - Optional parameters for pagination and filtering.
+ * @param args.options.offset - The number of items to skip before starting to collect the result set.
+ * @param args.options.limit - The maximum number of items to return.
+ * @param args.options.where - Conditions to filter the table items.
+ * @param args.options.orderBy - The criteria to sort the results.
+ */
 export async function getTableItemsData(args: {
   aptosConfig: AptosConfig;
   options?: PaginationArgs & WhereArg<TableItemsBoolExp> & OrderByArg<GetTableItemsDataResponse[0]>;
@@ -56,6 +76,18 @@ export async function getTableItemsData(args: {
   return data.table_items;
 }
 
+/**
+ * Retrieves metadata for table items based on specified options.
+ *
+ * @param args - The arguments for retrieving table items metadata.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.options - Optional parameters for pagination and filtering.
+ * @param args.options.offset - The number of items to skip before starting to collect the result set.
+ * @param args.options.limit - The maximum number of items to return.
+ * @param args.options.where - Conditions to filter the results.
+ * @param args.options.orderBy - The order in which to return the results.
+ * @returns A promise that resolves to an array of table metadata.
+ */
 export async function getTableItemsMetadata(args: {
   aptosConfig: AptosConfig;
   options?: PaginationArgs & WhereArg<TableMetadatasBoolExp> & OrderByArg<GetTableItemsMetadataResponse[0]>;

package/src/internal/transaction.ts

@@ -26,6 +26,15 @@ import { sleep } from "../utils/helpers";
 import { memoizeAsync } from "../utils/memoize";
 import { getIndexerLastSuccessVersion, getProcessorStatus } from "./general";
 
+/**
+ * Retrieve a list of transactions based on the specified options.
+ *
+ * @param {Object} args - The parameters for retrieving transactions.
+ * @param {Object} args.aptosConfig - The configuration object for Aptos.
+ * @param {Object} args.options - The options for pagination.
+ * @param {number} args.options.offset - The number of transactions to skip before starting to collect the result set.
+ * @param {number} args.options.limit - The maximum number of transactions to return.
+ */
 export async function getTransactions(args: {
   aptosConfig: AptosConfig;
   options?: PaginationArgs;
@@ -39,6 +48,13 @@ export async function getTransactions(args: {
   });
 }
 
+/**
+ * Retrieves the estimated gas price for transactions on the Aptos network.
+ * This function helps users understand the current gas price, which is essential for transaction planning and cost estimation.
+ *
+ * @param args - The configuration parameters for the Aptos network.
+ * @param args.aptosConfig - The configuration object containing network details.
+ */
 export async function getGasPriceEstimation(args: { aptosConfig: AptosConfig }) {
   const { aptosConfig } = args;
 
@@ -56,6 +72,14 @@ export async function getGasPriceEstimation(args: { aptosConfig: AptosConfig })
   )();
 }
 
+/**
+ * Retrieves the transaction details associated with a specific ledger version.
+ *
+ * @param args - The arguments for the transaction retrieval.
+ * @param args.aptosConfig - The configuration settings for the Aptos client.
+ * @param args.ledgerVersion - The ledger version for which to retrieve the transaction.
+ * @returns The transaction details for the specified ledger version.
+ */
 export async function getTransactionByVersion(args: {
   aptosConfig: AptosConfig;
   ledgerVersion: AnyNumber;
@@ -69,6 +93,14 @@ export async function getTransactionByVersion(args: {
   return data;
 }
 
+/**
+ * Retrieves transaction details using the specified transaction hash.
+ *
+ * @param args - The arguments for retrieving the transaction.
+ * @param args.aptosConfig - The configuration settings for the Aptos client.
+ * @param args.transactionHash - The hash of the transaction to retrieve.
+ * @returns A promise that resolves to the transaction details.
+ */
 export async function getTransactionByHash(args: {
   aptosConfig: AptosConfig;
   transactionHash: HexInput;
@@ -82,6 +114,16 @@ export async function getTransactionByHash(args: {
   return data;
 }
 
+/**
+ * Checks if a transaction is currently pending based on its hash.
+ * This function helps determine the status of a transaction in the Aptos network.
+ *
+ * @param args - The arguments for checking the transaction status.
+ * @param args.aptosConfig - The configuration settings for connecting to the Aptos network.
+ * @param args.transactionHash - The hash of the transaction to check.
+ * @returns A boolean indicating whether the transaction is pending.
+ * @throws An error if the transaction cannot be retrieved due to reasons other than a 404 status.
+ */
 export async function isTransactionPending(args: {
   aptosConfig: AptosConfig;
   transactionHash: HexInput;
@@ -98,6 +140,14 @@ export async function isTransactionPending(args: {
   }
 }
 
+/**
+ * Waits for a transaction to be confirmed by its hash.
+ * This function allows you to monitor the status of a transaction until it is finalized.
+ *
+ * @param args - The arguments for the function.
+ * @param args.aptosConfig - The configuration settings for the Aptos client.
+ * @param args.transactionHash - The hash of the transaction to wait for.
+ */
 export async function longWaitForTransaction(args: {
   aptosConfig: AptosConfig;
   transactionHash: HexInput;
@@ -111,6 +161,20 @@ export async function longWaitForTransaction(args: {
   return data;
 }
 
+/**
+ * Waits for a transaction to be confirmed on the blockchain and handles potential errors during the process.
+ * This function allows you to monitor the status of a transaction until it is either confirmed or fails.
+ *
+ * @param args - The arguments for waiting for a transaction.
+ * @param args.aptosConfig - The configuration settings for Aptos.
+ * @param args.transactionHash - The hash of the transaction to wait for.
+ * @param args.options - Optional settings for waiting, including timeout and success check.
+ * @param args.options.timeoutSecs - The maximum time to wait for the transaction in seconds. Defaults to a predefined value.
+ * @param args.options.checkSuccess - A flag indicating whether to check the success status of the transaction. Defaults to true.
+ * @returns A promise that resolves to the transaction response once the transaction is confirmed.
+ * @throws WaitForTransactionError if the transaction times out or remains pending.
+ * @throws FailedTransactionError if the transaction fails.
+ */
 export async function waitForTransaction(args: {
   aptosConfig: AptosConfig;
   transactionHash: HexInput;
@@ -127,6 +191,12 @@ export async function waitForTransaction(args: {
   let backoffIntervalMs = 200;
   const backoffMultiplier = 1.5;
 
+  /**
+   * Handles API errors by throwing the last error or a timeout error for a failed transaction.
+   *
+   * @param e - The error object that occurred during the API call.
+   * @throws {Error} Throws the last error if it exists; otherwise, throws a WaitForTransactionError indicating a timeout.
+   */
   function handleAPIError(e: any) {
     // In short, this means we will retry if it was an AptosApiError and the code was 404 or 5xx.
     const isAptosApiError = e instanceof AptosApiError;
@@ -215,7 +285,12 @@ export async function waitForTransaction(args: {
 }
 
 /**
- * Waits for the indexer to sync up to the ledgerVersion. Timeout is 3 seconds.
+ * Waits for the indexer to sync up to the specified ledger version. The timeout is 3 seconds.
+ *
+ * @param args - The arguments for the function.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.minimumLedgerVersion - The minimum ledger version that the indexer should sync to.
+ * @param args.processorType - (Optional) The type of processor to check the last success version from.
  */
 export async function waitForIndexer(args: {
   aptosConfig: AptosConfig;
@@ -256,12 +331,22 @@ export async function waitForIndexer(args: {
 }
 
 /**
- * This error is used by `waitForTransaction` when waiting for a
- * transaction to time out or when the transaction response is undefined
+ * Represents an error that occurs when waiting for a transaction to complete.
+ * This error is thrown by the `waitForTransaction` function when a transaction
+ * times out or when the transaction response is undefined.
+ *
+ * @param message - A descriptive message for the error.
+ * @param lastSubmittedTransaction - The last submitted transaction response, if available.
  */
 export class WaitForTransactionError extends Error {
   public readonly lastSubmittedTransaction: TransactionResponse | undefined;
 
+  /**
+   * Constructs an instance of the class with a specified message and transaction response.
+   *
+   * @param message - The message associated with the transaction.
+   * @param lastSubmittedTransaction - The transaction response object containing details about the transaction.
+   */
   constructor(message: string, lastSubmittedTransaction: TransactionResponse | undefined) {
     super(message);
     this.lastSubmittedTransaction = lastSubmittedTransaction;
@@ -269,8 +354,11 @@ export class WaitForTransactionError extends Error {
 }
 
 /**
- * This error is used by `waitForTransaction` if `checkSuccess` is true.
- * See that function for more information.
+ * Represents an error that occurs when a transaction fails.
+ * This error is thrown by the `waitForTransaction` function when the `checkSuccess` parameter is set to true.
+ *
+ * @param message - A description of the error.
+ * @param transaction - The transaction response associated with the failure.
  */
 export class FailedTransactionError extends Error {
   public readonly transaction: TransactionResponse;
@@ -281,6 +369,16 @@ export class FailedTransactionError extends Error {
   }
 }
 
+/**
+ * Retrieves a block from the Aptos blockchain by its ledger version.
+ * This function allows you to obtain detailed information about a specific block, including its transactions if requested.
+ *
+ * @param args - The arguments for retrieving the block.
+ * @param args.aptosConfig - The configuration object for connecting to the Aptos node.
+ * @param args.ledgerVersion - The ledger version of the block to retrieve.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.withTransactions - Indicates whether to include transactions in the block data.
+ */
 export async function getBlockByVersion(args: {
   aptosConfig: AptosConfig;
   ledgerVersion: AnyNumber;
@@ -297,6 +395,16 @@ export async function getBlockByVersion(args: {
   return fillBlockTransactions({ block, ...args });
 }
 
+/**
+ * Retrieves a block from the Aptos blockchain by its height.
+ *
+ * @param args - The parameters for retrieving the block.
+ * @param args.aptosConfig - The configuration object for connecting to the Aptos network.
+ * @param args.blockHeight - The height of the block to retrieve.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.withTransactions - Indicates whether to include transactions in the block data.
+ * @returns A promise that resolves to the block data, potentially including its transactions.
+ */
 export async function getBlockByHeight(args: {
   aptosConfig: AptosConfig;
   blockHeight: AnyNumber;
@@ -313,8 +421,13 @@ export async function getBlockByHeight(args: {
 }
 
 /**
- * Fills in the block with transactions if not enough were returned
- * @param args
+ * Fills in the block with transactions if not enough were returned. This function ensures that the block contains all relevant
+ * transactions by fetching any missing ones based on the specified options.
+ * @param args - The arguments for filling the block transactions.
+ * @param args.aptosConfig - The configuration settings for Aptos.
+ * @param args.block - The block object that will be filled with transactions.
+ * @param args.options - Optional settings for fetching transactions.
+ * @param args.options.withTransactions - Indicates whether to include transactions in the block.
  */
 async function fillBlockTransactions(args: {
   aptosConfig: AptosConfig;

package/src/internal/transactionSubmission.ts

@@ -84,7 +84,7 @@ export async function generateTransaction(
  * ```
  * {
  *  rawTransaction: RawTransaction,
- *  secondarySignerAddresses? : Array<AccountAddress>,
+ *  secondarySignerAddresses?: Array<AccountAddress>,
  *  feePayerAddress?: AccountAddress
  * }
  * ```
@@ -96,6 +96,16 @@ export async function generateTransaction(
   return buildRawTransaction(args, payload);
 }
 
+/**
+ * Builds a transaction payload based on the provided configuration and input data.
+ * This function is essential for preparing transaction data for execution on the Aptos blockchain.
+ *
+ * @param args - The arguments for building the transaction payload.
+ * @param args.aptosConfig - Configuration settings for the Aptos network.
+ * @param args.data - Input data required to generate the transaction payload, which may include bytecode, multisig address,
+ * function name, function arguments, type arguments, and ABI.
+ * @returns A promise that resolves to the generated transaction payload instance.
+ */
 export async function buildTransactionPayload(
   args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
 ): Promise<AnyTransactionPayloadInstance> {
@@ -130,6 +140,16 @@ export async function buildTransactionPayload(
   return payload;
 }
 
+/**
+ * Builds a raw transaction based on the provided configuration and payload.
+ * This function helps in creating a transaction that can be sent to the Aptos blockchain.
+ *
+ * @param args - The arguments for generating the transaction.
+ * @param args.aptosConfig - The configuration settings for Aptos.
+ * @param args.sender - The address of the sender of the transaction.
+ * @param args.options - Additional options for the transaction.
+ * @param payload - The payload of the transaction, which defines the action to be performed.
+ */
 export async function buildRawTransaction(
   args: { aptosConfig: AptosConfig } & InputGenerateTransactionData,
   payload: AnyTransactionPayloadInstance,
@@ -162,10 +182,23 @@ export async function buildRawTransaction(
   });
 }
 
+/**
+ * Determine if the transaction input includes a fee payer.
+ *
+ * @param data - The input data for generating a transaction.
+ * @param data.withFeePayer - Indicates whether a fee payer is included in the transaction input.
+ * @returns A boolean value indicating if the transaction input has a fee payer.
+ */
 function isFeePayerTransactionInput(data: InputGenerateTransactionData): boolean {
   return data.withFeePayer === true;
 }
 
+/**
+ * Determines whether the provided transaction input data includes multiple agent signatures.
+ *
+ * @param data - The transaction input data to evaluate.
+ * @param data.secondarySignerAddresses - An array of secondary signer addresses, indicating multiple agents.
+ */
 function isMultiAgentTransactionInput(
   data: InputGenerateTransactionData,
 ): data is InputGenerateMultiAgentRawTransactionData {
@@ -173,13 +206,14 @@ function isMultiAgentTransactionInput(
 }
 
 /**
- * Builds a signing message that can be signed by external signers
+ * Builds a signing message that can be signed by external signers.
  *
- * Note: Please prefer using `signTransaction` unless signing outside the SDK
+ * Note: Please prefer using `signTransaction` unless signing outside the SDK.
  *
- * @param args.transaction AnyRawTransaction, as generated by `generateTransaction()`
+ * @param args - The arguments for generating the signing message.
+ * @param args.transaction - AnyRawTransaction, as generated by `generateTransaction()`.
  *
- * @return The message to be signed
+ * @returns The message to be signed.
  */
 export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
   const { transaction } = args;
@@ -187,19 +221,13 @@ export function getSigningMessage(args: { transaction: AnyRawTransaction }): Uin
 }
 
 /**
- * Sign a transaction that can later be submitted to chain
+ * Sign a transaction that can later be submitted to the chain.
  *
- * @param args.signer The signer account to sign the transaction
- * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
- * ```
- * {
- *  rawTransaction: RawTransaction,
- *  secondarySignerAddresses? : Array<AccountAddress>,
- *  feePayerAddress?: AccountAddress
- * }
- * ```
+ * @param args The arguments for signing the transaction.
+ * @param args.signer The signer account to sign the transaction.
+ * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses.
  *
- * @return The signer AccountAuthenticator
+ * @return The signer AccountAuthenticator.
  */
 export function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
   const { signer, transaction } = args;
@@ -209,7 +237,7 @@ export function signTransaction(args: { signer: Account; transaction: AnyRawTran
 export function signAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
   const { signer, transaction } = args;
 
-  // if transaction doesnt hold a "feePayerAddress" prop it means
+  // if transaction doesn't hold a "feePayerAddress" prop it means
   // this is not a fee payer transaction
   if (!transaction.feePayerAddress) {
     throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);
@@ -225,13 +253,18 @@ export function signAsFeePayer(args: { signer: Account; transaction: AnyRawTrans
 }
 
 /**
- * Simulates a transaction before singing it.
+ * Simulates a transaction before signing it to evaluate its potential outcome.
  *
- * @param args.signerPublicKey The signer public key
- * @param args.transaction The raw transaction to simulate
- * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction
- * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
- * @param args.options optional. A config to simulate the transaction with
+ * @param args The arguments for simulating the transaction.
+ * @param args.aptosConfig The configuration for the Aptos network.
+ * @param args.transaction The raw transaction to simulate.
+ * @param args.signerPublicKey The signer public key.
+ * @param args.secondarySignersPublicKeys Optional. For when the transaction involves multiple signers.
+ * @param args.feePayerPublicKey Optional. For when the transaction is sponsored by a fee payer.
+ * @param args.options Optional. A configuration object to customize the simulation process.
+ * @param args.options.estimateGasUnitPrice Optional. Indicates whether to estimate the gas unit price.
+ * @param args.options.estimateMaxGasAmount Optional. Indicates whether to estimate the maximum gas amount.
+ * @param args.options.estimatePrioritizedGasUnitPrice Optional. Indicates whether to estimate the prioritized gas unit price.
  */
 export async function simulateTransaction(
   args: { aptosConfig: AptosConfig } & InputSimulateTransactionData,
@@ -262,13 +295,15 @@ export async function simulateTransaction(
 }
 
 /**
- * Submit transaction to chain
+ * Submit a transaction to the Aptos blockchain.
  *
- * @param args.transaction A aptos transaction type
- * @param args.senderAuthenticator The account authenticator of the transaction sender
- * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
+ * @param args - The arguments for submitting the transaction.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos network.
+ * @param args.transaction - The Aptos transaction data to be submitted.
+ * @param args.senderAuthenticator - The account authenticator of the transaction sender.
+ * @param args.secondarySignerAuthenticators - Optional. Authenticators for additional signers in a multi-signer transaction.
  *
- * @return PendingTransactionResponse
+ * @returns PendingTransactionResponse - The response containing the status of the submitted transaction.
  */
 export async function submitTransaction(
   args: {
@@ -300,7 +335,7 @@ export async function signAndSubmitTransaction(
 ): Promise<PendingTransactionResponse> {
   const { aptosConfig, signer, feePayer, transaction } = args;
   // If the signer contains a KeylessAccount, await proof fetching in case the proof
-  // was fetched asyncronously.
+  // was fetched asynchronously.
   if (signer instanceof AbstractKeylessAccount || signer instanceof MultiKeyAccount) {
     await signer.waitForProofFetch();
   }
@@ -346,6 +381,17 @@ const packagePublishAbi: EntryFunctionABI = {
   parameters: [TypeTagVector.u8(), new TypeTagVector(TypeTagVector.u8())],
 };
 
+/**
+ * Publishes a package transaction to the Aptos blockchain.
+ * This function allows you to create and send a transaction that publishes a package with the specified metadata and bytecode.
+ *
+ * @param args - The arguments for the package transaction.
+ * @param args.aptosConfig - The configuration settings for the Aptos client.
+ * @param args.account - The address of the account sending the transaction.
+ * @param args.metadataBytes - The metadata associated with the package, represented as hexadecimal input.
+ * @param args.moduleBytecode - An array of module bytecode, each represented as hexadecimal input.
+ * @param args.options - Optional parameters for generating the transaction.
+ */
 export async function publicPackageTransaction(args: {
   aptosConfig: AptosConfig;
   account: AccountAddressInput;
@@ -382,7 +428,17 @@ const rotateAuthKeyAbi: EntryFunctionABI = {
 };
 
 /**
- * TODO: Need to refactor and move this function out of transactionSubmission
+ * Rotates the authentication key for a given account, allowing for enhanced security and management of account access.
+ *
+ * @param args - The arguments for rotating the authentication key.
+ * @param args.aptosConfig - The configuration settings for the Aptos network.
+ * @param args.fromAccount - The account from which the authentication key will be rotated.
+ * @param args.toNewPrivateKey - The new private key that will be associated with the account.
+ *
+ * @remarks
+ * This function requires the current authentication key and the new private key to sign a challenge that validates the rotation.
+ *
+ * TODO: Need to refactor and move this function out of transactionSubmission.
  */
 export async function rotateAuthKey(args: {
   aptosConfig: AptosConfig;