@aptos-labs/ts-sdk 1.29.1 → 1.31.0

package/src/client/post.ts

@@ -7,6 +7,9 @@ import { AptosResponse } from "./types";
 import { AnyNumber, ClientConfig, MimeType } from "../types";
 import { AptosApiType } from "../utils/const";
 
+/**
+ * Options for making a POST request, including the API client configuration.
+ */
 export type PostRequestOptions = {
   /**
    * The config for the API client
@@ -46,13 +49,25 @@ export type PostRequestOptions = {
   overrides?: ClientConfig;
 };
 
+/**
+ * Options for posting a request to Aptos, excluding the type field.
+ */
 export type PostAptosRequestOptions = Omit<PostRequestOptions, "type">;
 
 /**
- * Main function to do a Post request
+ * Executes a POST request to the specified URL with the provided options.
  *
- * @param options PostRequestOptions
- * @returns
+ * @param options - The options for the POST request.
+ * @param options.type - The type of the request.
+ * @param options.originMethod - The original method that initiated the request.
+ * @param options.path - The path for the request.
+ * @param options.body - The body content to be sent with the request.
+ * @param options.acceptType - The type of response expected from the server.
+ * @param options.contentType - The content type of the request body.
+ * @param options.params - Additional parameters to include in the request.
+ * @param options.aptosConfig - Configuration settings for the Aptos request.
+ * @param options.overrides - Any overrides for the default request behavior.
+ * @returns The response from the POST request.
  */
 export async function post<Req extends {}, Res extends {}>(
   options: PostRequestOptions,
@@ -77,6 +92,16 @@ export async function post<Req extends {}, Res extends {}>(
   );
 }
 
+/**
+ * Sends a request to the Aptos full node using the specified options.
+ * This function allows you to interact with the Aptos blockchain by sending requests to the full node.
+ *
+ * @param options - The options for the request.
+ * @param options.aptosConfig - Configuration settings for the Aptos client.
+ * @param options.aptosConfig.clientConfig - Client-specific configuration settings.
+ * @param options.aptosConfig.fullnodeConfig - Full node-specific configuration settings.
+ * @param options.overrides - Additional overrides for the request.
+ */
 export async function postAptosFullNode<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {
@@ -94,6 +119,17 @@ export async function postAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Sends a request to the Aptos indexer with the specified options.
+ * This function allows you to interact with the Aptos indexer and customize the request using various configurations.
+ *
+ * @param options - The options for the request to the Aptos indexer.
+ * @param options.aptosConfig - Configuration settings specific to the Aptos client and indexer.
+ * @param options.aptosConfig.clientConfig - The client configuration settings.
+ * @param options.aptosConfig.indexerConfig - The indexer configuration settings.
+ * @param options.overrides - Additional overrides for the request.
+ * @param options.overrides.HEADERS - Custom headers to include in the request.
+ */
 export async function postAptosIndexer<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {
@@ -111,6 +147,17 @@ export async function postAptosIndexer<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Sends a request to the Aptos faucet to obtain test tokens.
+ * This function modifies the provided configuration to ensure that the API_KEY is not included in the request.
+ *
+ * @param options - The options for the request.
+ * @param options.aptosConfig - The configuration settings for the Aptos client.
+ * @param options.aptosConfig.clientConfig - The client-specific configuration settings.
+ * @param options.aptosConfig.clientConfig.HEADERS - Optional headers to include in the request.
+ * @param options.aptosConfig.faucetConfig - The configuration settings specific to the faucet.
+ * @param options.overrides - Additional overrides for the request configuration.
+ */
 export async function postAptosFaucet<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {
@@ -137,10 +184,13 @@ export async function postAptosFaucet<Req extends {}, Res extends {}>(
 }
 
 /**
- * Makes a post request to the pepper service
+ * Makes a post request to the pepper service.
  *
- * @param options GetAptosRequestOptions
- * @returns AptosResponse
+ * @param options - The options for the request.
+ * @param options.url - The URL to which the request is sent.
+ * @param options.headers - The headers to include in the request.
+ * @param options.body - The body of the request.
+ * @returns A promise that resolves to the response from the pepper service.
  */
 export async function postAptosPepperService<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
@@ -148,6 +198,13 @@ export async function postAptosPepperService<Req extends {}, Res extends {}>(
   return post<Req, Res>({ ...options, type: AptosApiType.PEPPER });
 }
 
+/**
+ * Sends a request to the Aptos proving service with the specified options.
+ *
+ * @param options - The options for the request to the Aptos proving service.
+ * @param options.type - The type of the request, which should be set to AptosApiType.PROVER.
+ * @param options.data - The data to be included in the request.
+ */
 export async function postAptosProvingService<Req extends {}, Res extends {}>(
   options: PostAptosRequestOptions,
 ): Promise<AptosResponse<Req, Res>> {

package/src/client/types.ts

@@ -25,6 +25,9 @@ export interface AptosResponse<Req, Res> {
   request?: Req;
 }
 
+/**
+ * Options for handling errors in the Aptos API.
+ */
 type AptosApiErrorOpts = {
   apiType: AptosApiType;
   aptosRequest: AptosRequest;
@@ -32,14 +35,15 @@ type AptosApiErrorOpts = {
 };
 
 /**
- * The type returned from an API error
+ * Represents an error returned from the Aptos API.
+ * This class encapsulates the details of the error, including the request URL, response status, and additional data.
  *
- * @param name - the error name "AptosApiError"
- * @param url the url the request was made to
- * @param status - the response status. i.e. 400
- * @param statusText - the response message
- * @param data the response data
- * @param request - the AptosRequest
+ * @param name - The name of the error, which is always "AptosApiError".
+ * @param url - The URL to which the request was made.
+ * @param status - The HTTP response status code (e.g., 400).
+ * @param statusText - The message associated with the response status.
+ * @param data - The response data returned from the API.
+ * @param request - The original AptosRequest that triggered the error.
  */
 export class AptosApiError extends Error {
   readonly url: string;
@@ -52,7 +56,16 @@ export class AptosApiError extends Error {
 
   readonly request: AptosRequest;
 
-  /** @internal this constructor is for sdk internal use - do not instantiate outside of the SDK codebase */
+  /**
+   * Constructs an instance of AptosApiError with relevant error details.
+   *
+   * @param opts - The options for creating the AptosApiError.
+   * @param opts.apiType - The type of API that generated the error.
+   * @param opts.aptosRequest - The request object that caused the error.
+   * @param opts.aptosResponse - The response object containing error details.
+   *
+   * @internal This constructor is for SDK internal use - do not instantiate outside the SDK codebase.
+   */
   constructor({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts) {
     super(deriveErrorMessage({ apiType, aptosRequest, aptosResponse }));
 
@@ -65,8 +78,17 @@ export class AptosApiError extends Error {
   }
 }
 
+/**
+ * Derives an error message from the Aptos API response, providing context for debugging.
+ * This function helps in understanding the nature of the error encountered during an API request.
+ *
+ * @param {AptosApiErrorOpts} opts - The options for deriving the error message.
+ * @param {AptosApiType} opts.apiType - The type of API being called.
+ * @param {AptosRequest} opts.aptosRequest - The original request made to the Aptos API.
+ * @param {AptosResponse} opts.aptosResponse - The response received from the Aptos API.
+ */
 function deriveErrorMessage({ apiType, aptosRequest, aptosResponse }: AptosApiErrorOpts): string {
-  // extract the W3C trace_id from the response headers if it exists. Some services set this in the response and it's useful for debugging.
+  // extract the W3C trace_id from the response headers if it exists. Some services set this in the response, and it's useful for debugging.
   // See https://www.w3.org/TR/trace-context/#relationship-between-the-headers .
   const traceId = aptosResponse.headers?.traceparent?.split("-")[1];
   const traceIdString = traceId ? `(trace_id:${traceId}) ` : "";
@@ -86,7 +108,7 @@ function deriveErrorMessage({ apiType, aptosRequest, aptosResponse }: AptosApiEr
     return `${errorPrelude}: ${JSON.stringify(aptosResponse.data)}`;
   }
 
-  // This is the generic/catch-all case. We received some response from the API but it doesn't appear to be a well-known structure.
+  // This is the generic/catch-all case. We received some response from the API, but it doesn't appear to be a well-known structure.
   // We print http status codes and the response body (after some trimming),
   // in the hope that this gives enough context what went wrong without printing overly huge messages.
   return `${errorPrelude} status: ${aptosResponse.statusText}(code:${
@@ -96,9 +118,14 @@ function deriveErrorMessage({ apiType, aptosRequest, aptosResponse }: AptosApiEr
 
 const SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH = 400;
 
-// this function accepts a payload of any type (probably an object) and serializes it to a string
-// Since we don't know the type or size of the payload and we don't want to add a huge object in full to the error message
-// we limit the to the first 200 and last 200 characters of the serialized payload and put a "..." in the middle.
+/**
+ * This function accepts a payload of any type (probably an object) and serializes it to a string
+ * Since we don't know the type or size of the payload, and we don't want to add a huge object in full to the error message
+ * we limit the to the first 200 and last 200 characters of the serialized payload and put a "..." in the middle.
+ * @param payload - The payload to serialize, which can be of any type.
+ *
+ * @returns A string representation of the serialized payload, potentially truncated.
+ */
 function serializeAnyPayloadForErrorMessage(payload: any): string {
   const serializedPayload = JSON.stringify(payload);
   if (serializedPayload.length <= SERIALIZED_PAYLOAD_TRIM_TO_MAX_LENGTH) {

package/src/core/account/utils/address.ts

@@ -21,7 +21,7 @@ export const createObjectAddress = (creatorAddress: AccountAddress, seed: Uint8A
 };
 
 /**
- * Creates an resource address from creator address and seed
+ * Creates a resource address from creator address and seed
  *
  * @param creatorAddress The creator account address
  * @param seed The seed in either Uint8Array | string type

package/src/core/accountAddress.ts

@@ -9,7 +9,7 @@ import { TransactionArgument } from "../transactions/instances/transactionArgume
 import { HexInput, ScriptTransactionArgumentVariants } from "../types";
 
 /**
- * This enum is used to explain why an address was invalid.
+ * Provides reasons for an address was invalid.
  */
 export enum AddressInvalidReason {
   INCORRECT_NUMBER_OF_BYTES = "incorrect_number_of_bytes",
@@ -21,6 +21,9 @@ export enum AddressInvalidReason {
   INVALID_PADDING_ZEROES = "INVALID_PADDING_ZEROES",
 }
 
+/**
+ * The input for an account address, which can be either a hexadecimal string or a standard account address.
+ */
 export type AccountAddressInput = HexInput | AccountAddress;
 
 /**
@@ -70,7 +73,10 @@ export class AccountAddress extends Serializable implements TransactionArgument
   /**
    * Creates an instance of AccountAddress from a Uint8Array.
    *
-   * @param args.data A Uint8Array representing an account address.
+   * This function ensures that the input data is exactly 32 bytes long, which is required for a valid account address.
+   *
+   * @param input A Uint8Array representing an account address.
+   * @throws ParsingError if the input length is not equal to 32 bytes.
    */
   constructor(input: Uint8Array) {
     super();
@@ -84,21 +90,20 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * Returns whether an address is special, where special is defined as 0x0 to 0xf
-   * inclusive. In other words, the last byte of the address must be < 0b10000 (16)
+   * Determines if the address is classified as special, which is defined as 0x0 to 0xf inclusive.
+   * In other words, the last byte of the address must be < 0b10000 (16)
    * and every other byte must be zero.
    *
-   * For more information on how special addresses are defined see AIP-40:
+   * For more information on how special addresses are defined, see AIP-40:
    * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
    *
-   * @returns true if the address is special, false if not.
+   * @returns true if the address is special, false otherwise.
    */
   isSpecial(): boolean {
     return (
       this.data.slice(0, this.data.length - 1).every((byte) => byte === 0) && this.data[this.data.length - 1] < 0b10000
     );
   }
-
   // ===
   // Methods for representing an instance of AccountAddress as other types.
   // ===
@@ -106,10 +111,8 @@ export class AccountAddress extends Serializable implements TransactionArgument
   /**
    * Return the AccountAddress as a string as per AIP-40.
    * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
-   *
-   * In short, it means that special addresses are represented in SHORT form, meaning
-   * 0x0 through to 0xf inclusive, and every other address is represented in LONG form,
-   * meaning 0x + 64 hex characters.
+   * This representation returns special addresses in SHORT form (0xf)
+   * and other addresses in LONG form (0x + 64 characters).
    *
    * @returns AccountAddress as a string conforming to AIP-40.
    */
@@ -118,13 +121,11 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * NOTE: Prefer to use `toString` where possible.
-   *
-   * Return the AccountAddress as a string as per AIP-40 but without the leading 0x.
+   * Return the AccountAddress as a string conforming to AIP-40 but without the leading 0x.
    *
-   * Learn more by reading the docstring of `toString`.
+   * NOTE: Prefer to use `toString` where possible.
    *
-   * @returns AccountAddress as a string conforming to AIP-40 but without the leading 0x.
+   * @returns AccountAddress as a string without the leading 0x.
    */
   toStringWithoutPrefix(): string {
     let hex = bytesToHex(this.data);
@@ -135,13 +136,9 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * NOTE: Prefer to use `toString` where possible.
-   *
-   * Whereas toString will format special addresses (as defined by isSpecial) using the
-   * SHORT form (no leading 0s), this format the address in the LONG format
-   * unconditionally.
+   * Convert the account address to a string in LONG format, which is always 0x followed by 64 hex characters.
    *
-   * This means it will be 0x + 64 hex characters.
+   * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
    *
    * @returns AccountAddress as a string in LONG form.
    */
@@ -150,23 +147,20 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * NOTE: Prefer to use `toString` where possible.
-   *
-   * Whereas toString will format special addresses (as defined by isSpecial) using the
-   * SHORT form (no leading 0s), this function will include leading zeroes. The string
-   * will not have a leading zero.
+   * Returns the account address as a string in LONG form without a leading 0x.
+   * This function will include leading zeroes and will produce a string of 64 hex characters.
    *
-   * This means it will be 64 hex characters without a leading 0x.
+   * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
    *
-   * @returns AccountAddress as a string in LONG form without a leading 0x.
+   * @returns {string} The account address in LONG form.
    */
   toStringLongWithoutPrefix(): string {
     return bytesToHex(this.data);
   }
 
   /**
-   * Get the inner hex data. The inner data is already a Uint8Array so no conversion
-   * is taking place here, it just returns the inner data.
+   * Get the inner data as a Uint8Array.
+   * The inner data is already a Uint8Array, so no conversion takes place.
    *
    * @returns Hex data as Uint8Array
    */
@@ -189,11 +183,23 @@ export class AccountAddress extends Serializable implements TransactionArgument
     serializer.serializeFixedBytes(this.data);
   }
 
+  /**
+   * Serializes the current instance into a byte sequence suitable for entry functions.
+   * This allows for the proper encoding of data when interacting with entry functions in the blockchain.
+   *
+   * @param serializer - The serializer instance used to convert the data into bytes.
+   */
   serializeForEntryFunction(serializer: Serializer): void {
     const bcsBytes = this.bcsToBytes();
     serializer.serializeBytes(bcsBytes);
   }
 
+  /**
+   * Serializes the current instance for use in a script function by encoding it into a byte sequence.
+   * This process involves serializing the variant index and the instance data, making it suitable for transmission.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   */
   serializeForScriptFunction(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.Address);
     serializer.serialize(this);
@@ -201,6 +207,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
 
   /**
    * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
+   * This function allows you to convert a byte representation of an AccountAddress into an instance of AccountAddress.
    * @param deserializer The deserializer to deserialize the AccountAddress from.
    * @returns An instance of AccountAddress.
    * @example
@@ -238,10 +245,14 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * - SHORT for non-special addresses.
    * - Any address without a leading 0x.
    *
-   * Learn more about the different address formats by reading AIP-40:
-   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+   * @param input - A hex string representing an account address.
+   *
+   * @throws {ParsingError} If the hex string does not start with 0x or is not in a valid format.
+   *
+   * @note This function has strict parsing behavior. For relaxed behavior, please use the `fromString` function.
    *
-   * @param input A hex string representing an account address.
+   * @see AIP-40 documentation for more details on address formats:
+   * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
    *
    * @returns An instance of AccountAddress.
    */
@@ -295,9 +306,11 @@ export class AccountAddress extends Serializable implements TransactionArgument
    * Learn more about the different address formats by reading AIP-40:
    * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
    *
-   * @param input A hex string representing an account address.
+   * @param input - A hex string representing an account address.
    *
    * @returns An instance of AccountAddress.
+   *
+   * @throws ParsingError if the hex string is too short, too long, or contains invalid characters.
    */
   static fromString(input: string): AccountAddress {
     let parsedInput = input;
@@ -338,10 +351,12 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * Convenience method for creating an AccountAddress from all known inputs.
+   * Convenience method for creating an AccountAddress from various input types.
+   * This function accepts a string, Uint8Array, or an existing AccountAddress instance and returns the corresponding
+   * AccountAddress.
    *
-   * This handles, Uint8array, string, and AccountAddress itself
-   * @param input
+   * @param input - The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array,
+   * or an existing AccountAddress.
    */
   static from(input: AccountAddressInput): AccountAddress {
     if (typeof input === "string") {
@@ -354,10 +369,9 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * Convenience method for creating an AccountAddress from all known inputs.
+   * Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.
    *
-   * This handles, Uint8array, string, and AccountAddress itself
-   * @param input
+   * @param input - The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.
    */
   static fromStrict(input: AccountAddressInput): AccountAddress {
     if (typeof input === "string") {
@@ -368,19 +382,19 @@ export class AccountAddress extends Serializable implements TransactionArgument
     }
     return input;
   }
-
   // ===
   // Methods for checking validity.
   // ===
 
   /**
-   * Check if the string is a valid AccountAddress.
+   * Check if the provided input is a valid AccountAddress.
    *
-   * @param args.input A hex string representing an account address.
-   * @param args.strict If true, use strict parsing behavior. If false, use relaxed parsing behavior.
+   * @param args - The arguments for validation.
+   * @param args.input - A hex string representing an account address.
+   * @param args.strict - If true, use strict parsing behavior; if false, use relaxed parsing behavior.
    *
-   * @returns valid = true if the string is valid, valid = false if not. If the string
-   * is not valid, invalidReason will be set explaining why it is invalid.
+   * @returns An object indicating whether the address is valid. If valid, valid = true; if not, valid = false with additional details.
+   * If the address is invalid, invalidReason will explain why it is invalid, and invalidReasonMessage will provide the error message.
    */
   static isValid(args: { input: AccountAddressInput; strict?: boolean }): ParsingResult<AddressInvalidReason> {
     try {
@@ -400,10 +414,9 @@ export class AccountAddress extends Serializable implements TransactionArgument
   }
 
   /**
-   * Return whether AccountAddresses are equal. AccountAddresses are considered equal
-   * if their underlying byte data is identical.
+   * Determine if two AccountAddresses are equal based on their underlying byte data.
    *
-   * @param other The AccountAddress to compare to.
+   * @param other - The AccountAddress to compare to.
    * @returns true if the AccountAddresses are equal, false if not.
    */
   equals(other: AccountAddress): boolean {

package/src/core/authenticationKey.ts

@@ -10,11 +10,13 @@ import { Serializable, Serializer } from "../bcs/serializer";
 import { Deserializer } from "../bcs/deserializer";
 
 /**
- * Each account stores an authentication key. Authentication key enables account owners to rotate
- * their private key(s) associated with the account without changing the address that hosts their account.
+ * Represents an authentication key used for account management. Each account stores an authentication key that enables account
+ * owners to rotate their private key(s) without changing the address that hosts their account. The authentication key is a
+ * SHA3-256 hash of data and is always 32 bytes in length.
+ *
  * @see {@link https://aptos.dev/concepts/accounts | Account Basics}
  *
- * Account addresses can be derived from AuthenticationKey
+ * Account addresses can be derived from the AuthenticationKey.
  */
 export class AuthenticationKey extends Serializable {
   /**
@@ -29,6 +31,15 @@ export class AuthenticationKey extends Serializable {
    */
   public readonly data: Hex;
 
+  /**
+   * Creates an instance of the AuthenticationKey using the provided hex input.
+   * This ensures that the hex input is valid and conforms to the required length for an Authentication Key.
+   *
+   * @param args - The arguments for constructing the AuthenticationKey.
+   * @param args.data - The hex input data to be used for the Authentication Key.
+   * @throws {Error} Throws an error if the length of the provided hex input is not equal to the required Authentication Key
+   * length.
+   */
   constructor(args: { data: HexInput }) {
     super();
     const { data } = args;
@@ -39,13 +50,18 @@ export class AuthenticationKey extends Serializable {
     this.data = hex;
   }
 
+  /**
+   * Serializes the fixed bytes data into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeFixedBytes(this.data.toUint8Array());
   }
 
   /**
    * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
-   * @param deserializer The deserializer to deserialize the AuthenticationKey from.
+   * @param deserializer - The deserializer to deserialize the AuthenticationKey from.
    * @returns An instance of AuthenticationKey.
    */
   static deserialize(deserializer: Deserializer): AuthenticationKey {
@@ -53,14 +69,26 @@ export class AuthenticationKey extends Serializable {
     return new AuthenticationKey({ data: bytes });
   }
 
-  toString(): string {
-    return this.data.toString();
-  }
-
+  /**
+   * Convert the internal data representation to a Uint8Array.
+   *
+   * This function is useful for obtaining a byte representation of the data, which can be utilized for serialization or transmission.
+   *
+   * @returns Uint8Array representation of the internal data.
+   */
   toUint8Array(): Uint8Array {
     return this.data.toUint8Array();
   }
 
+  /**
+   * Generates an AuthenticationKey from the specified scheme and input bytes.
+   * This function is essential for creating a valid authentication key based on a given scheme.
+   *
+   * @param args - The arguments for generating the AuthenticationKey.
+   * @param args.scheme - The authentication key scheme to use.
+   * @param args.input - The input data in hexadecimal format to derive the key.
+   * @returns An instance of AuthenticationKey containing the generated key data.
+   */
   static fromSchemeAndBytes(args: { scheme: AuthenticationKeyScheme; input: HexInput }): AuthenticationKey {
     const { scheme, input } = args;
     const inputBytes = Hex.fromHexInput(input).toUint8Array();
@@ -72,12 +100,12 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * @deprecated Use `fromPublicKey` instead
-   * Derives an AuthenticationKey from the public key seed bytes and an explicit derivation scheme.
-   *
-   * This facilitates targeting a specific scheme for deriving an authentication key from a public key.
+   * Derives an AuthenticationKey from the provided public key using a specified derivation scheme.
    *
-   * @param args - the public key and scheme to use for the derivation
+   * @deprecated Use `fromPublicKey` instead.
+   * @param args - The arguments for deriving the authentication key.
+   * @param args.publicKey - The public key used for the derivation.
+   * @param args.scheme - The scheme to use for deriving the authentication key.
    */
   public static fromPublicKeyAndScheme(args: { publicKey: AccountPublicKey; scheme: AuthenticationKeyScheme }) {
     const { publicKey } = args;
@@ -85,11 +113,11 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * Converts a PublicKey(s) to an AuthenticationKey, using the derivation scheme inferred from the
-   * instance of the PublicKey type passed in.
+   * Converts a PublicKey to an AuthenticationKey using the derivation scheme inferred from the provided PublicKey instance.
    *
-   * @param args.publicKey
-   * @returns AuthenticationKey
+   * @param args - The arguments for the function.
+   * @param args.publicKey - The PublicKey to be converted.
+   * @returns AuthenticationKey - The derived AuthenticationKey.
    */
   static fromPublicKey(args: { publicKey: AccountPublicKey }): AuthenticationKey {
     const { publicKey } = args;
@@ -97,10 +125,9 @@ export class AuthenticationKey extends Serializable {
   }
 
   /**
-   * Derives an account address from an AuthenticationKey. Since an AccountAddress is also 32 bytes,
-   * the AuthenticationKey bytes are directly translated to an AccountAddress.
+   * Derives an account address from an AuthenticationKey by translating the AuthenticationKey bytes directly to an AccountAddress.
    *
-   * @returns AccountAddress
+   * @returns AccountAddress - The derived account address.
    */
   derivedAddress(): AccountAddress {
     return new AccountAddress(this.data.toUint8Array());

package/src/core/common.ts

@@ -12,6 +12,12 @@ export class ParsingError<T> extends Error {
    */
   public invalidReason: T;
 
+  /**
+   * Creates an instance of the error with a specified message and invalid reason.
+   *
+   * @param message The error message that describes the issue.
+   * @param invalidReason The reason why the input is considered invalid.
+   */
   constructor(message: string, invalidReason: T) {
     super(message);
     this.invalidReason = invalidReason;