@aptos-labs/ts-sdk 1.33.1 → 1.33.2

package/src/transactions/transactionBuilder/helpers.ts

@@ -18,6 +18,8 @@ import { MoveFunction, MoveFunctionId } from "../../types";
  *
  * @param arg - The argument to check, which can be of various types.
  * @returns A boolean indicating whether the argument is a boolean.
+ * @group Implementation
+ * @category Transactions
  */
 export function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {
   return typeof arg === "boolean";
@@ -28,6 +30,8 @@ export function isBool(arg: SimpleEntryFunctionArgumentTypes): arg is boolean {
  *
  * @param arg - The value to be checked for string type.
  * @returns A boolean indicating whether the argument is a string.
+ * @group Implementation
+ * @category Transactions
  */
 export function isString(arg: any): arg is string {
   return typeof arg === "string";
@@ -38,6 +42,8 @@ export function isString(arg: any): arg is string {
  *
  * @param arg - The argument to check, which can be of various types.
  * @returns A boolean indicating whether the argument is a number.
+ * @group Implementation
+ * @category Transactions
  */
 export function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {
   return typeof arg === "number";
@@ -50,6 +56,8 @@ export function isNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number {
  *
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | undefined {
   if (isNumber(arg)) {
@@ -66,6 +74,8 @@ export function convertNumber(arg: SimpleEntryFunctionArgumentTypes): number | u
  * 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.
+ * @group Implementation
+ * @category Transactions
  */
 export function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is number | bigint | string {
   return typeof arg === "number" || typeof arg === "bigint" || typeof arg === "string";
@@ -76,6 +86,8 @@ export function isLargeNumber(arg: SimpleEntryFunctionArgumentTypes): arg is num
  *
  * @param arg - The argument to check for emptiness.
  * @returns A boolean indicating whether the argument is empty.
+ * @group Implementation
+ * @category Transactions
  */
 export function isEmptyOption(arg: SimpleEntryFunctionArgumentTypes): arg is null | undefined {
   return arg === null || arg === undefined;
@@ -86,6 +98,8 @@ export function isEmptyOption(arg: SimpleEntryFunctionArgumentTypes): arg is nul
  * 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.
+ * @group Implementation
+ * @category Transactions
  */
 export function isEncodedEntryFunctionArgument(
   arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
@@ -95,6 +109,8 @@ export function isEncodedEntryFunctionArgument(
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsBool(arg) ||
     /**
@@ -102,12 +118,16 @@ export function isEncodedEntryFunctionArgument(
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsU16(arg) ||
     /**
@@ -115,6 +135,8 @@ export function isEncodedEntryFunctionArgument(
      *
      * @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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsU32(arg) ||
     /**
@@ -122,6 +144,8 @@ export function isEncodedEntryFunctionArgument(
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsU64(arg) ||
     /**
@@ -129,6 +153,8 @@ export function isEncodedEntryFunctionArgument(
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsU128(arg) ||
     /**
@@ -136,6 +162,8 @@ export function isEncodedEntryFunctionArgument(
      *
      * @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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsU256(arg) ||
     /**
@@ -143,12 +171,16 @@ export function isEncodedEntryFunctionArgument(
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsString(arg) ||
     /**
@@ -156,51 +188,83 @@ export function isEncodedEntryFunctionArgument(
      * 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.
+     * @group Implementation
+     * @category Transactions
      */
     isBcsFixedBytes(arg) ||
     arg instanceof MoveVector ||
     arg instanceof MoveOption
   );
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsBool(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is Bool {
   return arg instanceof Bool;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsAddress(
   arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
 ): arg is AccountAddress {
   return arg instanceof AccountAddress;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsString(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is MoveString {
   return arg instanceof MoveString;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsFixedBytes(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is FixedBytes {
   return arg instanceof FixedBytes;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsU8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U8 {
   return arg instanceof U8;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsU16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U16 {
   return arg instanceof U16;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsU32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U32 {
   return arg instanceof U32;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsU64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U64 {
   return arg instanceof U64;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U128 {
   return arg instanceof U128;
 }
-
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256 {
   return arg instanceof U256;
 }
@@ -212,6 +276,8 @@ export function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionA
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function isScriptDataInput(
   arg: InputGenerateTransactionPayloadDataWithRemoteABI | InputGenerateTransactionPayloadData,
@@ -225,6 +291,8 @@ export function isScriptDataInput(
  *
  * @param expectedType - The type that was expected for the argument.
  * @param position - The position of the argument that caused the type mismatch.
+ * @group Implementation
+ * @category Transactions
  */
 export function throwTypeMismatch(expectedType: string, position: number) {
   throw new Error(`Type mismatch for argument ${position}, expected '${expectedType}'`);
@@ -239,6 +307,8 @@ export function throwTypeMismatch(expectedType: string, position: number) {
  *
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
   const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
@@ -255,6 +325,8 @@ export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function getFunctionParts(functionArg: MoveFunctionId) {
   const funcNameParts = functionArg.split("::");

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -54,6 +54,8 @@ const TEXT_ENCODER = new TextEncoder();
  *
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<TypeTag> {
   return (
@@ -75,6 +77,8 @@ export function standardizeTypeTags(typeArguments?: Array<TypeArgument>): Array<
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export async function fetchFunctionAbi(
   moduleAddress: string,
@@ -102,6 +106,8 @@ export async function fetchFunctionAbi(
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export async function fetchEntryFunctionAbi(
   moduleAddress: string,
@@ -145,6 +151,8 @@ export async function fetchEntryFunctionAbi(
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export async function fetchViewFunctionAbi(
   moduleAddress: string,
@@ -192,6 +200,8 @@ export async function fetchViewFunctionAbi(
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function convertArgument(
   functionName: string,
@@ -217,6 +227,8 @@ export function convertArgument(
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function checkOrConvertArgument(
   arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes,
@@ -235,6 +247,8 @@ export function checkOrConvertArgument(
      * @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.
+     * @group Implementation
+     * @category Transactions
      */
     checkType(param, arg, position);
     return arg;
@@ -253,6 +267,8 @@ export function checkOrConvertArgument(
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 function parseArg(
   arg: SimpleEntryFunctionArgumentTypes,
@@ -274,6 +290,8 @@ function parseArg(
      *
      * @param moveOption - The name of the move option that caused the type mismatch.
      * @param position - The position where the error occurred.
+     * @group Implementation
+     * @category Transactions
      */
     throwTypeMismatch("boolean", position);
   }
@@ -425,6 +443,8 @@ function parseArg(
  * @param param
  * @param arg
  * @param position
+ * @group Implementation
+ * @category Transactions
  */
 function checkType(param: TypeTag, arg: EntryFunctionArgumentTypes, position: number) {
   if (param.isBool()) {

package/src/transactions/transactionBuilder/signingMessage.ts

@@ -3,6 +3,8 @@
 
 /**
  * This file handles the generation of the signing message.
+ * @group Implementation
+ * @category Transactions
  */
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { RAW_TRANSACTION_SALT, RAW_TRANSACTION_WITH_DATA_SALT } from "../../utils/const";
@@ -21,6 +23,8 @@ import { Serializable } from "../../bcs";
  *   - rawTransaction - The raw transaction data.
  *
  * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
+ * @group Implementation
+ * @category Transactions
  */
 export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {
   if (transaction.feePayerAddress) {
@@ -45,6 +49,8 @@ export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTra
  * @param domainSeparator - A domain separator that starts with 'APTOS::'.
  *
  * @returns The Uint8Array of the signing message.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateSigningMessage(bytes: Uint8Array, domainSeparator: string): Uint8Array {
   const hash = sha3Hash.create();
@@ -76,6 +82,8 @@ export function generateSigningMessage(bytes: Uint8Array, domainSeparator: strin
  * @param serializable - An object that has a BCS serialized form.
  *
  * @returns The Uint8Array of the signing message.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateSigningMessageForSerializable(serializable: Serializable): Uint8Array {
   return generateSigningMessage(serializable.bcsToBytes(), `APTOS::${serializable.constructor.name}`);
@@ -88,6 +96,8 @@ export function generateSigningMessageForSerializable(serializable: Serializable
  * @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.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateSigningMessageForTransaction(transaction: AnyRawTransaction): Uint8Array {
   const rawTxn = deriveTransactionType(transaction);

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -95,11 +95,21 @@ import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
  *
  * @returns TransactionPayload - The generated transaction payload, which can be of type TransactionPayloadScript,
  * TransactionPayloadMultiSig, or TransactionPayloadEntryFunction.
+ * @group Implementation
+ * @category Transactions
  */
 export async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export async function generateTransactionPayload(
   args: InputEntryFunctionDataWithRemoteABI,
 ): Promise<TransactionPayloadEntryFunction>;
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export async function generateTransactionPayload(
   args: InputMultiSigDataWithRemoteABI,
 ): Promise<TransactionPayloadMultiSig>;
@@ -113,6 +123,8 @@ export async function generateTransactionPayload(
  * @param args.data GenerateTransactionPayloadData
  *
  * @return TransactionPayload
+ * @group Implementation
+ * @category Transactions
  */
 export async function generateTransactionPayload(
   args: InputGenerateTransactionPayloadDataWithRemoteABI,
@@ -148,9 +160,19 @@ export async function generateTransactionPayload(
  * @param args.multisigAddress - (Optional) The address for a multisig transaction if applicable.
  *
  * @throws Error if the type argument count does not match the ABI or if the number of function arguments is incorrect.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateTransactionPayloadWithABI(args: InputEntryFunctionDataWithABI): TransactionPayloadEntryFunction;
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function generateTransactionPayloadWithABI(args: InputMultiSigDataWithABI): TransactionPayloadMultiSig;
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function generateTransactionPayloadWithABI(
   args: InputGenerateTransactionPayloadDataWithABI,
 ): AnyTransactionPayloadInstance {
@@ -179,6 +201,8 @@ export function generateTransactionPayloadWithABI(
      * @param arg - The argument to be converted.
      * @param i - The index of the argument in the function call.
      * @param typeArguments - Additional type arguments that may be required for the conversion.
+     * @group Implementation
+     * @category Transactions
      */
     // TODO: Fix JSDoc
     convertArgument(args.function, functionAbi, arg, i, typeArguments),
@@ -222,6 +246,8 @@ export function generateTransactionPayloadWithABI(
  * @param args.abi - The ABI (Application Binary Interface) of the module.
  *
  * @returns The generated payload for the view function call.
+ * @group Implementation
+ * @category Transactions
  */
 export async function generateViewFunctionPayload(args: InputViewFunctionDataWithRemoteABI): Promise<EntryFunction> {
   const { moduleAddress, moduleName, functionName } = getFunctionParts(args.function);
@@ -253,6 +279,8 @@ export async function generateViewFunctionPayload(args: InputViewFunctionDataWit
  *
  * @throws Error if the type argument count does not match the ABI or if the function arguments
  * do not match the expected parameters defined in the ABI.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWithABI): EntryFunction {
   const functionAbi = args.abi;
@@ -293,6 +321,8 @@ export function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWi
  * @param args.typeArguments - The type arguments that will be standardized.
  * @param args.functionArguments - The arguments for the function being called.
  * @returns A new instance of TransactionPayloadScript.
+ * @group Implementation
+ * @category Transactions
  */
 function generateTransactionPayloadScript(args: InputScriptData) {
   return new TransactionPayloadScript(
@@ -315,6 +345,8 @@ function generateTransactionPayloadScript(args: InputScriptData) {
  * @param args.feePayerAddress - The address of the fee payer for sponsored transactions.
  *
  * @returns RawTransaction - The generated raw transaction.
+ * @group Implementation
+ * @category Transactions
  */
 export async function generateRawTransaction(args: {
   aptosConfig: AptosConfig;
@@ -353,6 +385,8 @@ export async function generateRawTransaction(args: {
     /**
      * Check if is sponsored transaction to honor AIP-52
      * {@link https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-52.md}
+     * @group Implementation
+     * @category Transactions
      */
     if (feePayerAddress && AccountAddress.from(feePayerAddress).equals(AccountAddress.ZERO)) {
       // Handle sponsored transaction generation with the option that
@@ -402,8 +436,14 @@ export async function generateRawTransaction(args: {
  * @param args.secondarySignerAddresses - Optional. An array of addresses for additional signers in a multi-signature transaction.
  * @param args.feePayerAddress - Optional. The address of the fee payer for sponsored transactions.
  * @returns An instance of a transaction, which may include secondary signer addresses and a fee payer address.
+ * @group Implementation
+ * @category Transactions
  */
 export async function buildTransaction(args: InputGenerateSingleSignerRawTransactionArgs): Promise<SimpleTransaction>;
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export async function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;
 
 /**
@@ -427,6 +467,8 @@ export async function buildTransaction(args: InputGenerateMultiAgentRawTransacti
  *  feePayerAddress?: AccountAddress
  * }
  * ```
+ * @group Implementation
+ * @category Transactions
  */
 export async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction> {
   const { aptosConfig, sender, payload, options, feePayerAddress } = args;
@@ -466,6 +508,8 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
  * @param args.options - Optional. Additional options for simulating the transaction.
  *
  * @returns A signed serialized transaction that can be simulated.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {
   const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;
@@ -553,6 +597,10 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
   return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();
 }
 
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
   if (!publicKey) {
     return new AccountAuthenticatorNoAccountAuthenticator();
@@ -614,6 +662,8 @@ export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
  *
  * @throws Error if the feePayerAuthenticator is not provided for a fee payer transaction.
  * @throws Error if additionalSignersAuthenticators are not provided for a multi-signer transaction.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array {
   const { transaction, feePayerAuthenticator, additionalSignersAuthenticators } = args;
@@ -659,6 +709,8 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
 /**
  * Hashes the set of values using a SHA-3 256 hash algorithm.
  * @param input - An array of UTF-8 strings or Uint8Array byte arrays to be hashed.
+ * @group Implementation
+ * @category Transactions
  */
 export function hashValues(input: (Uint8Array | string)[]): Uint8Array {
   const hash = sha3Hash.create();
@@ -670,6 +722,8 @@ export function hashValues(input: (Uint8Array | string)[]): Uint8Array {
 
 /**
  * The domain separated prefix for hashing transactions
+ * @group Implementation
+ * @category Transactions
  */
 const TRANSACTION_PREFIX = hashValues(["APTOS::Transaction"]);
 
@@ -682,6 +736,8 @@ const TRANSACTION_PREFIX = hashValues(["APTOS::Transaction"]);
  * @param args.payload - The payload containing the transaction details.
  * @param args.sender - The address of the sender initiating the transaction.
  * @param args.sequenceNumber - The sequence number of the transaction for the sender.
+ * @group Implementation
+ * @category Transactions
  */
 export function generateUserTransactionHash(args: InputSubmitTransactionData): string {
   const signedTransaction = generateSignedTransaction(args);
@@ -702,6 +758,8 @@ export function generateUserTransactionHash(args: InputSubmitTransactionData): s
  * @param aptosConfig - Configuration settings for Aptos.
  * @param abi - An optional ABI to use if already available.
  * @param fetch - A function to fetch the ABI if it is not provided.
+ * @group Implementation
+ * @category Transactions
  */
 async function fetchAbi<T extends FunctionABI>({
   key,