@aptos-labs/ts-sdk 1.33.1 → 1.33.2-sc.0

package/src/bcs/serializable/moveStructs.ts

@@ -44,6 +44,8 @@ import { EntryFunctionArgument, TransactionArgument } from "../../transactions/i
  *
  * @param values an Array<T> of values where T is a class that implements Serializable
  * @returns a `MoveVector<T>` with the values `values`
+ * @group Implementation
+ * @category BCS
  */
 export class MoveVector<T extends Serializable & EntryFunctionArgument>
   extends Serializable
@@ -56,6 +58,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * This constructor sets up the internal vector based on the provided value.
    *
    * @param values - The initial value to be stored in the vector, or null to initialize an empty vector.
+   * @group Implementation
+   * @category BCS
    */
   constructor(values: Array<T>) {
     super();
@@ -67,6 +71,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * This allows the data to be properly formatted for transmission or storage.
    *
    * @param serializer - The serializer instance used to serialize the byte sequence.
+   * @group Implementation
+   * @category BCS
    */
   serializeForEntryFunction(serializer: Serializer): void {
     const bcsBytes = this.bcsToBytes();
@@ -76,11 +82,15 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
   /**
    * NOTE: This function will only work when the inner values in the `MoveVector` are `U8`s.
    * @param serializer
+   * @group Implementation
+   * @category BCS
    */
 
   /**
    * Serialize the string as a fixed byte string without the length prefix for use in a script function.
    * @param serializer - The serializer used to convert the byte vector into a format suitable for a script function.
+   * @group Implementation
+   * @category BCS
    */
   serializeForScriptFunction(serializer: Serializer): void {
     // This checks if the type of a non-empty vector is of type other than U8.  If so, we use the Serialized
@@ -108,6 +118,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U8([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U8(values: Array<number> | HexInput): MoveVector<U8> {
     let numbers: Array<number>;
@@ -141,6 +153,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U16([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
 
    */
   static U16(values: Array<number>): MoveVector<U16> {
@@ -160,6 +174,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```
    * const v = MoveVector.U32([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
 
    */
   static U32(values: Array<number>): MoveVector<U32> {
@@ -178,6 +194,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U64([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U64(values: Array<AnyNumber>): MoveVector<U64> {
     return new MoveVector<U64>(values.map((v) => new U64(v)));
@@ -194,6 +212,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U128([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U128(values: Array<AnyNumber>): MoveVector<U128> {
     return new MoveVector<U128>(values.map((v) => new U128(v)));
@@ -211,6 +231,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * ```typescript
    * const v = MoveVector.U256([1, 2, 3, 4]);
    * ```
+   * @group Implementation
+   * @category BCS
    */
   static U256(values: Array<AnyNumber>): MoveVector<U256> {
     return new MoveVector<U256>(values.map((v) => new U256(v)));
@@ -227,6 +249,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * @example
    *    * const v = MoveVector.Bool([true, false, true, false]);
+   * @group Implementation
+   * @category BCS
    */
   static Bool(values: Array<boolean>): MoveVector<Bool> {
     return new MoveVector<Bool>(values.map((v) => new Bool(v)));
@@ -242,6 +266,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    *
    * @example
    * const v = MoveVector.MoveString(["hello", "world"]);
+   * @group Implementation
+   * @category BCS
    */
   static MoveString(values: Array<string>): MoveVector<MoveString> {
     return new MoveVector<MoveString>(values.map((v) => new MoveString(v)));
@@ -252,6 +278,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * This function will serialize the value if it is present.
    *
    * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category BCS
    */
   serialize(serializer: Serializer): void;
   serialize(serializer: Serializer): void {
@@ -274,6 +302,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
    * @param cls the class to typecast the input values to, must be a Serializable and Deserializable type.
    * @returns a MoveVector of the corresponding class T
    *
+   * @group Implementation
+   * @category BCS
    */
   static deserialize<T extends Serializable & EntryFunctionArgument>(
     deserializer: Deserializer,
@@ -294,6 +324,8 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
  * and deserialization of byte data, as well as converting to a MoveVector.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class Serialized extends Serializable implements TransactionArgument {
   public readonly value: Uint8Array;
@@ -325,6 +357,8 @@ export class Serialized extends Serializable implements TransactionArgument {
    * This function allows you to convert serialized data into a usable MoveVector format.
    *
    * @param cls - The class type of the elements in the MoveVector.
+   * @group Implementation
+   * @category BCS
    */
   toMoveVector<T extends Serializable & EntryFunctionArgument>(cls: Deserializable<T>): MoveVector<T> {
     const deserializer = new Deserializer(this.bcsToBytes());
@@ -341,6 +375,8 @@ export class Serialized extends Serializable implements TransactionArgument {
  * functions and script functions.
  *
  * @extends Serializable
+ * @group Implementation
+ * @category BCS
  */
 export class MoveString extends Serializable implements TransactionArgument {
   public value: string;
@@ -410,6 +446,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @throws {Error} Throws an error if the MoveOption does not contain a value.
    *
    * @returns {T} The contained value if present.
+   * @group Implementation
+   * @category BCS
    */
   unwrap(): T {
     if (!this.isSome()) {
@@ -423,6 +461,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * Check if the MoveOption has a value.
    *
    * @returns {boolean} Returns true if there is exactly one value in the MoveOption.
+   * @group Implementation
+   * @category BCS
    */
   isSome(): boolean {
     return this.vec.values.length === 1;
@@ -444,6 +484,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U8> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U8(value?: number | null): MoveOption<U8> {
     return new MoveOption<U8>(value !== null && value !== undefined ? new U8(value) : undefined);
@@ -459,6 +501,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U16> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U16(value?: number | null): MoveOption<U16> {
     return new MoveOption<U16>(value !== null && value !== undefined ? new U16(value) : undefined);
@@ -474,6 +518,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U32> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U32(value?: number | null): MoveOption<U32> {
     return new MoveOption<U32>(value !== null && value !== undefined ? new U32(value) : undefined);
@@ -489,6 +535,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U64> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U64(value?: AnyNumber | null): MoveOption<U64> {
     return new MoveOption<U64>(value !== null && value !== undefined ? new U64(value) : undefined);
@@ -504,6 +552,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U128> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U128(value?: AnyNumber | null): MoveOption<U128> {
     return new MoveOption<U128>(value !== null && value !== undefined ? new U128(value) : undefined);
@@ -519,6 +569,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<U256> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static U256(value?: AnyNumber | null): MoveOption<U256> {
     return new MoveOption<U256>(value !== null && value !== undefined ? new U256(value) : undefined);
@@ -534,6 +586,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<Bool> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static Bool(value?: boolean | null): MoveOption<Bool> {
     return new MoveOption<Bool>(value !== null && value !== undefined ? new Bool(value) : undefined);
@@ -550,6 +604,8 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
    * @param value the value used to fill the MoveOption. If `value` is undefined
    * the resulting MoveOption's .isSome() method will return false.
    * @returns a MoveOption<MoveString> with an inner value `value`
+   * @group Implementation
+   * @category BCS
    */
   static MoveString(value?: string | null): MoveOption<MoveString> {
     return new MoveOption<MoveString>(value !== null && value !== undefined ? new MoveString(value) : undefined);

package/src/bcs/serializer.ts

@@ -17,6 +17,8 @@ import { AnyNumber, Uint16, Uint32, Uint8 } from "../types";
  * This class serves as a base class for all serializable types. It facilitates
  * composable serialization of complex types and enables the serialization of
  * instances to their BCS (Binary Canonical Serialization) representation.
+ * @group Implementation
+ * @category BCS
  */
 export abstract class Serializable {
   abstract serialize(serializer: Serializer): void;
@@ -25,6 +27,8 @@ export abstract class Serializable {
    * Serializes a `Serializable` value to its BCS representation.
    * This function is the TypeScript SDK equivalent of `bcs::to_bytes` in Move.
    * @returns the BCS representation of the Serializable instance as a byte buffer.
+   * @group Implementation
+   * @category BCS
    */
   bcsToBytes(): Uint8Array {
     const serializer = new Serializer();
@@ -36,6 +40,8 @@ export abstract class Serializable {
    * Converts the BCS-serialized bytes of a value into a Hex instance.
    * This function provides a Hex representation of the BCS-serialized data for easier handling and manipulation.
    * @returns A Hex instance with the BCS-serialized bytes loaded into its underlying Uint8Array.
+   * @group Implementation
+   * @category BCS
    */
   bcsToHex(): Hex {
     const bcsBytes = this.bcsToBytes();
@@ -64,6 +70,8 @@ export abstract class Serializable {
  * It provides methods to serialize strings, bytes, numbers, and other serializable objects
  * using the Binary Coded Serialization (BCS) layout. The serialized data can be retrieved as a
  * Uint8Array.
+ * @group Implementation
+ * @category BCS
  */
 export class Serializer {
   private buffer: ArrayBuffer;
@@ -75,6 +83,8 @@ export class Serializer {
    * The `length` must be greater than 0.
    *
    * @param length - The size of the buffer in bytes.
+   * @group Implementation
+   * @category BCS
    */
   constructor(length: number = 64) {
     if (length <= 0) {
@@ -89,6 +99,8 @@ export class Serializer {
    * This function dynamically resizes the buffer if the current size is insufficient.
    *
    * @param bytes - The number of bytes to ensure the buffer can handle.
+   * @group Implementation
+   * @category BCS
    */
   private ensureBufferWillHandleSize(bytes: number) {
     while (this.buffer.byteLength < this.offset + bytes) {
@@ -102,6 +114,8 @@ export class Serializer {
    * Appends the specified values to the buffer, ensuring that the buffer can accommodate the new data.
    *
    * @param {Uint8Array} values - The values to be appended to the buffer.
+   * @group Implementation
+   * @category BCS
    */
   protected appendToBuffer(values: Uint8Array) {
     this.ensureBufferWillHandleSize(values.length);
@@ -116,6 +130,8 @@ export class Serializer {
    * @param fn.byteOffset - The byte offset at which to write the value.
    * @param fn.value - The numeric value to serialize into the buffer.
    * @param fn.littleEndian - Optional flag indicating whether to use little-endian byte order (defaults to true).
+   * @group Implementation
+   * @category BCS
    */
   // TODO: JSDoc bytesLength and value
   private serializeWithFunction(
@@ -145,6 +161,8 @@ export class Serializer {
    * serializer.serializeStr("1234abcd");
    * assert(serializer.toUint8Array() === new Uint8Array([8, 49, 50, 51, 52, 97, 98, 99, 100]));
    * ```
+   * @group Implementation
+   * @category BCS
    */
   serializeStr(value: string) {
     const textEncoder = new TextEncoder();
@@ -158,6 +176,8 @@ export class Serializer {
    * BCS layout for "bytes": bytes_length | bytes
    * where bytes_length is a u32 integer encoded as a uleb128 integer, equal to the length of the bytes array.
    * @param value - The byte array to serialize.
+   * @group Implementation
+   * @category BCS
    */
   serializeBytes(value: Uint8Array) {
     this.serializeU32AsUleb128(value.length);
@@ -170,6 +190,8 @@ export class Serializer {
    * When deserializing, the number of bytes to deserialize needs to be passed in.
 
    * @param value - The Uint8Array to be serialized.
+   * @group Implementation
+   * @category BCS
    */
   serializeFixedBytes(value: Uint8Array) {
     this.appendToBuffer(value);
@@ -181,6 +203,8 @@ export class Serializer {
    * The BCS layout for a boolean uses one byte, where "0x01" represents true and "0x00" represents false.
    *
    * @param value - The boolean value to serialize.
+   * @group Implementation
+   * @category BCS
    */
   serializeBool(value: boolean) {
     /**
@@ -189,6 +213,8 @@ export class Serializer {
      *
      * @param value - The value to be checked for boolean type.
      * @throws {Error} Throws an error if the value is not a boolean.
+     * @group Implementation
+     * @category BCS
      */
     ensureBoolean(value);
     const byteValue = value ? 1 : 0;
@@ -200,6 +226,8 @@ export class Serializer {
    * BCS layout for "uint8": One byte. Binary format in little-endian representation.
    *
    * @param value - The Uint8 value to serialize.
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(0, MAX_U8_NUMBER)
   serializeU8(value: Uint8) {
@@ -209,6 +237,8 @@ export class Serializer {
   /**
    * Serializes a uint16 number.
    *
+   * @group Implementation
+   * @category BCS
 
    */
 
@@ -223,6 +253,8 @@ export class Serializer {
    * serializer.serializeU16(4660);
    * assert(serializer.toUint8Array() === new Uint8Array([0x34, 0x12]));
    * ```
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(0, MAX_U16_NUMBER)
   serializeU16(value: Uint16) {
@@ -239,6 +271,8 @@ export class Serializer {
    * assert(serializer.toUint8Array() === new Uint8Array([0x78, 0x56, 0x34, 0x12]));
    * ```
    * @param value - The 32-bit unsigned integer value to serialize.
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(0, MAX_U32_NUMBER)
   serializeU32(value: Uint32) {
@@ -256,6 +290,8 @@ export class Serializer {
    * serializer.serializeU64(1311768467750121216);
    * assert(serializer.toUint8Array() === new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
    * ```
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(BigInt(0), MAX_U64_BIG_INT)
   serializeU64(value: AnyNumber) {
@@ -271,6 +307,8 @@ export class Serializer {
    * Serializes a U128 value into a format suitable for storage or transmission.
    *
    * @param value - The U128 value to serialize, represented as a number.
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(BigInt(0), MAX_U128_BIG_INT)
   serializeU128(value: AnyNumber) {
@@ -287,6 +325,8 @@ export class Serializer {
    * This function is essential for encoding large numbers in a compact format suitable for transmission or storage.
    *
    * @param value - The U256 value to serialize, represented as an AnyNumber.
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(BigInt(0), MAX_U256_BIG_INT)
   serializeU256(value: AnyNumber) {
@@ -303,6 +343,8 @@ export class Serializer {
    * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
    *
    * @param val - The 32-bit unsigned integer value to be serialized.
+   * @group Implementation
+   * @category BCS
    */
   @checkNumberRange(0, MAX_U32_NUMBER)
   serializeU32AsUleb128(val: Uint32) {
@@ -322,6 +364,8 @@ export class Serializer {
    * This function allows you to retrieve the byte representation of the buffer up to the current offset.
    *
    * @returns Uint8Array - The byte array representation of the buffer.
+   * @group Implementation
+   * @category BCS
    */
   toUint8Array(): Uint8Array {
     return new Uint8Array(this.buffer).slice(0, this.offset);
@@ -333,6 +377,8 @@ export class Serializer {
    * @param value The Serializable value to serialize.
    *
    * @returns the serializer instance
+   * @group Implementation
+   * @category BCS
    */
   serialize<T extends Serializable>(value: T): void {
     // NOTE: The `serialize` method called by `value` is defined in `value`'s
@@ -358,6 +404,8 @@ export class Serializer {
    * // serializedBytes is now the BCS-serialized bytes
    * // The equivalent value in Move would be:
    * // `bcs::to_bytes(&vector<address> [@0x1, @0x2, @0xa, @0xb])`;
+   * @group Implementation
+   * @category BCS
    */
   serializeVector<T extends Serializable>(values: Array<T>): void {
     this.serializeU32AsUleb128(values.length);
@@ -382,6 +430,8 @@ export class Serializer {
    * serializer.serializeOption(new AccountAddress(...));  // Serializes optional Serializable
    * serializer.serializeOption(undefined);  // Serializes none case
    * ```
+   * @group Implementation
+   * @category BCS
    */
   serializeOption<T extends Serializable | string | Uint8Array>(value?: T, len?: number): void {
     const hasValue = value !== undefined;
@@ -411,6 +461,8 @@ export class Serializer {
    * BCS layout for undefined: 0
    *
    * @param value - The optional string to serialize. If undefined, it will serialize as 0.
+   * @group Implementation
+   * @category BCS
    */
   serializeOptionStr(value?: string): void {
     if (value === undefined) {
@@ -422,12 +474,19 @@ export class Serializer {
   }
 }
 
+/**
+ * @group Implementation
+ * @category BCS
+ */
 export function ensureBoolean(value: unknown): asserts value is boolean {
   if (typeof value !== "boolean") {
     throw new Error(`${value} is not a boolean value`);
   }
 }
-
+/**
+ * @group Implementation
+ * @category BCS
+ */
 export const outOfRangeErrorMessage = (value: AnyNumber, min: AnyNumber, max: AnyNumber) =>
   `${value} is out of range: [${min}, ${max}]`;
 
@@ -438,6 +497,8 @@ export const outOfRangeErrorMessage = (value: AnyNumber, min: AnyNumber, max: An
  * @param value - The number to validate.
  * @param minValue - The minimum allowable value (inclusive).
  * @param maxValue - The maximum allowable value (inclusive).
+ * @group Implementation
+ * @category BCS
  */
 export function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T, maxValue: T) {
   const valueBigInt = BigInt(value);
@@ -452,6 +513,8 @@ export function validateNumberInRange<T extends AnyNumber>(value: T, minValue: T
  *
  * @param minValue - The input argument must be greater than or equal to this value.
  * @param maxValue - The input argument must be less than or equal to this value.
+ * @group Implementation
+ * @category BCS
  */
 function checkNumberRange<T extends AnyNumber>(minValue: T, maxValue: T) {
   return (target: unknown, propertyKey: string, descriptor: PropertyDescriptor) => {

package/src/cli/localNode.ts

@@ -7,9 +7,11 @@ import { platform } from "os";
 import { sleep } from "../utils/helpers";
 
 /**
- * Represents a local node for running a testnet environment.
- * This class provides methods to start, stop, and check the status of the local testnet process.
+ * Represents a local node for running a localnet environment.
+ * This class provides methods to start, stop, and check the status of the localnet process.
  * It manages the lifecycle of the node process and ensures that it is operational before executing tests.
+ * @group Implementation
+ * @category CLI
  */
 export class LocalNode {
   readonly MAXIMUM_WAIT_TIME_SEC = 75;
@@ -29,6 +31,8 @@ export class LocalNode {
    *
    * @returns {Promise<void>} A promise that resolves to true if the process was successfully killed.
    * @throws {Error} If there is an error while attempting to kill the process.
+   * @group Implementation
+   * @category CLI
    */
   async stop(): Promise<void> {
     await new Promise((resolve, reject) => {
@@ -41,6 +45,8 @@ export class LocalNode {
        * @param callback - A function that is called after the termination attempt is complete.
        * @param callback.err - An error object if the termination failed; otherwise, null.
        * @param callback.resolve - A boolean indicating whether the termination was successful.
+       * @group Implementation
+       * @category CLI
        */
       kill(this.process.pid, (err) => {
         if (err) {
@@ -53,10 +59,12 @@ export class LocalNode {
   }
 
   /**
-   * Runs a local testnet and waits for the process to be up.
+   * Runs a localnet and waits for the process to be up.
    * If the local node process is already running, it returns without starting the process.
    *
    * @returns {Promise<void>} A promise that resolves when the process is up.
+   * @group Implementation
+   * @category CLI
    */
   async run(): Promise<void> {
     const nodeIsUp = await this.checkIfProcessIsUp();
@@ -68,11 +76,13 @@ export class LocalNode {
   }
 
   /**
-   * Starts the local testnet by running the Aptos node with the specified command-line arguments.
+   * Starts the localnet by running the Aptos node with the specified command-line arguments.
    *
    * @returns {void}
    *
-   * @throws {Error} If there is an issue starting the local testnet.
+   * @throws {Error} If there is an issue starting the localnet.
+   * @group Implementation
+   * @category CLI
    */
   start(): void {
     const cliCommand = "npx";
@@ -105,10 +115,12 @@ export class LocalNode {
   }
 
   /**
-   * Waits for the local testnet process to be operational within a specified maximum wait time.
+   * Waits for the localnet process to be operational within a specified maximum wait time.
    * This function continuously checks if the process is up and will throw an error if it fails to start.
    *
    * @returns Promise<boolean> - Resolves to true if the process is up, otherwise throws an error.
+   * @group Implementation
+   * @category CLI
    */
   async waitUntilProcessIsUp(): Promise<boolean> {
     let operational = await this.checkIfProcessIsUp();
@@ -133,9 +145,11 @@ export class LocalNode {
   }
 
   /**
-   * Checks if the local testnet is up by querying the readiness endpoint.
+   * Checks if the localnet is up by querying the readiness endpoint.
    *
-   * @returns Promise<boolean> - A promise that resolves to true if the testnet is up, otherwise false.
+   * @returns Promise<boolean> - A promise that resolves to true if the localnet is up, otherwise false.
+   * @group Implementation
+   * @category CLI
    */
   async checkIfProcessIsUp(): Promise<boolean> {
     try {