@aptos-labs/ts-sdk 1.33.1 → 1.33.2

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 {

package/src/cli/move.ts

@@ -8,6 +8,8 @@ import { Network } from "../utils";
  * Class representing a Move package management utility for the Aptos blockchain.
  * This class provides methods to initialize directories, compile packages, run tests, publish modules, create objects, upgrade
  * packages, build transaction payloads, and run scripts.
+ * @group Implementation
+ * @category CLI
  */
 export class Move {
   /**
@@ -21,6 +23,8 @@ export class Move {
    * @param args.extraArguments - Optional extra arguments to include in the form of an array of strings.
    * Ex. ["--assume-yes","--gas-unit-price=10"]
    * @returns stdout
+   * @group Implementation
+   * @category CLI
    */
   async init(args: {
     network?: Network;
@@ -48,6 +52,8 @@ export class Move {
    * @param args.extraArguments - Optional extra arguments to include in the form of an array of strings.
    * Ex. ["--assume-yes","--gas-unit-price=10"]
    * @returns stdout
+   * @group Implementation
+   * @category CLI
    */
   async compile(args: {
     packageDirectoryPath: string;
@@ -78,6 +84,8 @@ export class Move {
    * @param args.extraArguments - Optional extra arguments to include in the form of an array of strings.
    * Ex. ["--assume-yes","--gas-unit-price=10"]
    * @returns The stdout output from running the tests.
+   * @group Implementation
+   * @category CLI
    */
   async test(args: {
     packageDirectoryPath: string;
@@ -109,6 +117,8 @@ export class Move {
    * @param args.extraArguments - Optional extra arguments to include in the form of an array of strings.
    * Ex. ["--assume-yes","--gas-unit-price=10"]
    * @returns stdout
+   * @group Implementation
+   * @category CLI
    */
   async publish(args: {
     packageDirectoryPath: string;
@@ -157,6 +167,8 @@ export class Move {
    * --named-addresses "launchpad_addr=0x123,initial_creator_addr=0x456" \
    * --profile my_profile \
    * --assume-yes
+   * @group Implementation
+   * @category CLI
    */
   async createObjectAndPublishPackage(args: {
     packageDirectoryPath: string;
@@ -202,6 +214,8 @@ export class Move {
    * @param args.extraArguments - Optional extra arguments to include in the form of an array of strings.
    * Ex. ["--assume-yes","--gas-unit-price=10"]
    * @returns stdout
+   * @group Implementation
+   * @category CLI
    */
   async upgradeObjectPackage(args: {
     packageDirectoryPath: string;
@@ -244,6 +258,8 @@ export class Move {
    * @param args.extraArguments - Optional extra arguments to include in the form of an array of strings.
    * Ex. ["--assume-yes","--gas-unit-price=10"]   *
    * @returns stdout
+   * @group Implementation
+   * @category CLI
    */
   async buildPublishPayload(args: {
     packageDirectoryPath: string;
@@ -286,6 +302,8 @@ export class Move {
    * Ex. ["--assume-yes","--gas-unit-price=10"]
    *
    * @returns The standard output from running the script.
+   * @group Implementation
+   * @category CLI
    */
   async runScript(args: {
     compiledScriptPath: string;
@@ -332,6 +350,8 @@ export class Move {
    * @param args - An array of strings representing the command-line arguments to be passed to the command.
    * @param showStdout - Show the standard output generated by the command.
    * @returns The standard output generated by the command.
+   * @group Implementation
+   * @category CLI
    */
   // eslint-disable-next-line class-methods-use-this
   private async runCommand(args: Array<string>, showStdout: boolean = true): Promise<{ result?: any; output: string }> {
@@ -388,6 +408,8 @@ export class Move {
    * @param namedAddresses - A Map where the key is a string representing the name and the value is an AccountAddress.
    * Ex. {'alice' => '0x123', 'bob' => '0x456'}
    * @returns An array of named addresses formatted as strings separated by a comma. Ex. "alice=0x123,bob=0x456"
+   * @group Implementation
+   * @category CLI
    */
   // eslint-disable-next-line class-methods-use-this
   private prepareNamedAddresses(namedAddresses: Map<string, AccountAddress>): Array<string> {
@@ -417,6 +439,8 @@ export class Move {
    *
    * @param namedAddresses - A record containing named addresses where the key is the name and the value is the AccountAddress.
    * @returns A Map where each key is a name and each value is the corresponding address.
+   * @group Implementation
+   * @category CLI
    */
   // eslint-disable-next-line class-methods-use-this
   private parseNamedAddresses(namedAddresses: Record<string, AccountAddress>): Map<string, AccountAddress> {
@@ -436,6 +460,8 @@ export class Move {
    * @param output - The output string containing the object address.
    * @returns The extracted object address.
    * @throws Error if the object address cannot be extracted from the output.
+   * @group Implementation
+   * @category CLI
    */
   // eslint-disable-next-line class-methods-use-this
   private extractAddressFromOutput(output: string): string {

package/src/client/core.ts

@@ -24,6 +24,8 @@ import { AptosApiError } from "../errors";
  * @param client - The client used to make the request.
  *
  * @returns The response from the request.
+ * @group Implementation
+ * @category Client
  */
 export async function request<Req, Res>(options: ClientRequest<Req>, client: Client): Promise<ClientResponse<Res>> {
   const { url, method, body, contentType, params, overrides, originMethod } = options;
@@ -62,6 +64,8 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
  * @param aptosConfig - The configuration information for the SDK client instance.
  * @param apiType - The type of API being accessed, which determines how the response is handled.
  * @returns The response from the API request or throws an AptosApiError if the request fails.
+ * @group Implementation
+ * @category Client
  */
 export async function aptosRequest<Req extends {}, Res extends {}>(
   aptosRequestOpts: AptosRequest,

package/src/client/get.ts

@@ -5,44 +5,64 @@ import { AptosApiType } from "../utils/const";
 
 /**
  * Options for making a GET request, including configuration for the API client.
+ * @group Implementation
+ * @category Client
  */
 export type GetRequestOptions = {
   /**
    * The config for the API client
+   * @group Implementation
+   * @category Client
    */
   aptosConfig: AptosConfig;
   /**
    * The type of API endpoint to call e.g. fullnode, indexer, etc
+   * @group Implementation
+   * @category Client
    */
   type: AptosApiType;
   /**
    * The name of the API method
+   * @group Implementation
+   * @category Client
    */
   originMethod: string;
   /**
    * The URL path to the API method
+   * @group Implementation
+   * @category Client
    */
   path: string;
   /**
    * The content type of the request body
+   * @group Implementation
+   * @category Client
    */
   contentType?: MimeType;
   /**
    * The accepted content type of the response of the API
+   * @group Implementation
+   * @category Client
    */
   acceptType?: MimeType;
   /**
    * The query parameters for the request
+   * @group Implementation
+   * @category Client
    */
   params?: Record<string, string | AnyNumber | boolean | undefined>;
   /**
    * Specific client overrides for this request to override aptosConfig
+   * @group Implementation
+   * @category Client
    */
   overrides?: ClientConfig;
 };
 
 /**
  * Options for making a request to the Aptos API, excluding the "type" field.
+ * @group Implementation
+ * @category Client
  */
 export type GetAptosRequestOptions = Omit<GetRequestOptions, "type">;
 
@@ -59,6 +79,8 @@ export type GetAptosRequestOptions = Omit<GetRequestOptions, "type">;
  * @param options.originMethod - The original method of the request.
  * @param options.type - The type of request being made.
  * @returns The response from the GET request.
+ * @group Implementation
+ * @category Client
  */
 export async function get<Req extends {}, Res extends {}>(
   options: GetRequestOptions,
@@ -96,6 +118,8 @@ export async function get<Req extends {}, Res extends {}>(
  * @param options.type - The type of API request being made.
  *
  * @returns A promise that resolves with the response from the Aptos full node.
+ * @group Implementation
+ * @category Client
  */
 export async function getAptosFullNode<Req extends {}, Res extends {}>(
   options: GetAptosRequestOptions,
@@ -121,6 +145,8 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
  * @param options.param1 - Description of param1.
  * @param options.param2 - Description of param2.
  * @returns AptosResponse - The response from the Aptos Pepper service.
+ * @group Implementation
+ * @category Client
  */
 export async function getAptosPepperService<Req extends {}, Res extends {}>(
   options: GetAptosRequestOptions,
@@ -128,7 +154,11 @@ export async function getAptosPepperService<Req extends {}, Res extends {}>(
   return get<Req, Res>({ ...options, type: AptosApiType.PEPPER });
 }
 
-/// This function is a helper for paginating using a function wrapping an API
+/**
+ * This function is a helper for paginating using a function wrapping an API
+ * @group Implementation
+ * @category Client
+ */
 export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,
 ): Promise<Res> {
@@ -149,6 +179,8 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
      * the cursor is a "state key" from the API perspective. Client
      * should not need to "care" what it represents but just use it
      * to query the next chunk of data.
+     * @group Implementation
+     * @category Client
      */
     cursor = response.headers["x-aptos-cursor"];
     // Now that we have the cursor (if any), we remove the headers before
@@ -159,3 +191,45 @@ export async function paginateWithCursor<Req extends Record<string, any>, Res ex
   } while (cursor !== null && cursor !== undefined);
   return out as Res;
 }
+
+/// This function is a helper for paginating using a function wrapping an API using offset instead of start
+export async function paginateWithObfuscatedCursor<Req extends Record<string, any>, Res extends Array<{}>>(
+  options: GetAptosRequestOptions,
+): Promise<Res> {
+  const out: any[] = [];
+  let cursor: string | undefined;
+  const requestParams = options.params as { offset?: string; limit?: number };
+  const totalLimit = requestParams.limit;
+  do {
+    // eslint-disable-next-line no-await-in-loop
+    const response = await get<Req, Res>({
+      type: AptosApiType.FULLNODE,
+      aptosConfig: options.aptosConfig,
+      originMethod: options.originMethod,
+      path: options.path,
+      params: requestParams,
+      overrides: options.overrides,
+    });
+    /**
+     * the cursor is a "state key" from the API perspective. Client
+     * should not need to "care" what it represents but just use it
+     * to query the next chunk of data.
+     */
+    cursor = response.headers["x-aptos-cursor"];
+    // Now that we have the cursor (if any), we remove the headers before
+    // adding these to the output of this function.
+    delete response.headers;
+    out.push(...response.data);
+    requestParams.offset = cursor;
+
+    // Re-evaluate length
+    if (totalLimit !== undefined) {
+      const newLimit = totalLimit - out.length;
+      if (newLimit <= 0) {
+        break;
+      }
+      requestParams.limit = newLimit;
+    }
+  } while (cursor !== null && cursor !== undefined);
+  return out as Res;
+}