@aptos-labs/ts-sdk 1.33.2 → 1.35.0-zeta.0

package/src/api/account.ts

@@ -1,8 +1,15 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account as AccountModule } from "../account";
-import { AccountAddress, PrivateKey, AccountAddressInput, createObjectAddress } from "../core";
+import { Account as AccountModule, EphemeralKeyPair } from "../account";
+import {
+  AccountAddress,
+  PrivateKey,
+  AccountAddressInput,
+  createObjectAddress,
+  AccountPublicKey,
+  PublicKey,
+} from "../core";
 import {
   AccountData,
   AnyNumber,
@@ -30,11 +37,13 @@ import {
   getAccountOwnedObjects,
   getAccountOwnedTokens,
   getAccountOwnedTokensFromCollectionAddress,
+  getAccountsForPublicKey,
   getAccountTokensCount,
   getAccountTransactionsCount,
   getInfo,
   getModule,
   getModules,
+  getPublicKeyFromAccountAddress,
   getResource,
   getResources,
   getTransactions,
@@ -47,12 +56,16 @@ import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 import { view } from "../internal/view";
 import { isEncodedStruct, parseEncodedStruct } from "../utils";
 import { memoizeAsync } from "../utils/memoize";
+import { AccountAbstraction } from "./account/abstraction";
+import { DeriveKeylessAccountParams } from "../internal/keyless";
 
 /**
  * A class to query all `Account` related queries on Aptos.
  * @group Account
  */
 export class Account {
+  abstraction: AccountAbstraction;
+
   /**
    * Creates an instance of the Aptos client with the provided configuration.
    *
@@ -73,7 +86,9 @@ export class Account {
    * ```
    * @group Account
    */
-  constructor(readonly config: AptosConfig) {}
+  constructor(readonly config: AptosConfig) {
+    this.abstraction = new AccountAbstraction(config);
+  }
 
   /**
    * Queries the current state for an Aptos account given its account address.
@@ -653,7 +668,7 @@ export class Account {
   }
 
   /**
-   * Retrieves the current amount of APT for a specified account.
+   * Retrieves the current amount of APT for a specified account. If the account does not exist, it will return 0.
    *
    * @param args The arguments for the account query.
    * @param args.accountAddress The account address for which to retrieve the APT amount.
@@ -894,4 +909,48 @@ export class Account {
   async deriveAccountFromPrivateKey(args: { privateKey: PrivateKey }): Promise<AccountModule> {
     return deriveAccountFromPrivateKey({ aptosConfig: this.config, ...args });
   }
+
+  async getPublicKeyFromAccountAddress(args: {
+    accountAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<PublicKey> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorType: ProcessorType.DEFAULT,
+    });
+    return getPublicKeyFromAccountAddress({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  async getAccountsForPublicKey(args: {
+    publicKey: AccountPublicKey;
+    minimumLedgerVersion?: AnyNumber;
+    options?: { verified?: boolean };
+  }): Promise<
+    {
+      accountAddress: AccountAddress;
+      publicKey: PublicKey;
+      verified: boolean;
+      lastTransactionVersion: number;
+    }[]
+  > {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorType: ProcessorType.DEFAULT,
+    });
+    return getAccountsForPublicKey({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  // deriveAccount(args: AccountDerivationParams | AccountDerivationParams[]): Promise<Account> {
+  //   return deriveAccount({ aptosConfig: this.config, ...args });
+  // }
 }
+
+// type AccountDerivationParams = { privateKey: PrivateKey } | DeriveKeylessAccountParams;

package/src/api/aptos.ts

@@ -15,6 +15,8 @@ import { Transaction } from "./transaction";
 import { Table } from "./table";
 import { Keyless } from "./keyless";
 import { AptosObject } from "./object";
+import { AccountAbstraction } from "./account/abstraction";
+import { Experimental } from "./experimental";
 
 /**
  * The main entry point for interacting with the Aptos APIs,
@@ -54,6 +56,8 @@ export class Aptos {
 
   readonly event: Event;
 
+  readonly experimental: Experimental;
+
   readonly faucet: Faucet;
 
   readonly fungibleAsset: FungibleAsset;
@@ -94,10 +98,12 @@ export class Aptos {
   constructor(settings?: AptosConfig) {
     this.config = new AptosConfig(settings);
     this.account = new Account(this.config);
+    this.abstraction = new AccountAbstraction(this.config);
     this.ans = new ANS(this.config);
     this.coin = new Coin(this.config);
     this.digitalAsset = new DigitalAsset(this.config);
     this.event = new Event(this.config);
+    this.experimental = new Experimental(this.config);
     this.faucet = new Faucet(this.config);
     this.fungibleAsset = new FungibleAsset(this.config);
     this.general = new General(this.config);
@@ -117,6 +123,7 @@ export interface Aptos
     Coin,
     DigitalAsset,
     Event,
+    Experimental,
     Faucet,
     FungibleAsset,
     General,
@@ -149,10 +156,12 @@ function applyMixin(targetClass: any, baseClass: any, baseClassProp: string) {
 }
 
 applyMixin(Aptos, Account, "account");
+applyMixin(Aptos, AccountAbstraction, "abstraction");
 applyMixin(Aptos, ANS, "ans");
 applyMixin(Aptos, Coin, "coin");
 applyMixin(Aptos, DigitalAsset, "digitalAsset");
 applyMixin(Aptos, Event, "event");
+applyMixin(Aptos, Experimental, "experimental");
 applyMixin(Aptos, Faucet, "faucet");
 applyMixin(Aptos, FungibleAsset, "fungibleAsset");
 applyMixin(Aptos, General, "general");

package/src/api/aptosConfig.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import aptosClient from "@aptos-labs/aptos-client";
+import aptosClient, { bcsRequest } from "@aptos-labs/aptos-client";
 import { AptosSettings, ClientConfig, Client, FullNodeConfig, IndexerConfig, FaucetConfig } from "../types";
 import {
   NetworkToNodeAPI,
@@ -140,7 +140,7 @@ export class AptosConfig {
     this.pepper = settings?.pepper;
     this.prover = settings?.prover;
     this.indexer = settings?.indexer;
-    this.client = settings?.client ?? { provider: aptosClient };
+    this.client = settings?.client ?? { provider: aptosClient, binaryProvider: bcsRequest };
     this.clientConfig = settings?.clientConfig ?? {};
     this.fullnodeConfig = settings?.fullnodeConfig ?? {};
     this.indexerConfig = settings?.indexerConfig ?? {};

package/src/api/experimental.ts

@@ -0,0 +1,64 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { LedgerVersionArg } from "../types";
+import { AptosConfig } from "./aptosConfig";
+import { InputViewFunctionData } from "../transactions";
+import { viewBinary } from "../internal/experimental";
+
+/**
+ * A class to have experimental functionality to the SDK.  Anything used here is subject to change.
+ * @group Experimental
+ * @experimental
+ */
+export class Experimental {
+  /**
+   * Initializes a new instance of the Aptos client with the provided configuration.
+   *
+   * @param config - The configuration settings for the Aptos client.
+   * @param config.network - The network to connect to (e.g., Testnet, Mainnet).
+   * @param config.nodeUrl - The URL of the Aptos node to connect to.
+   * @param config.faucetUrl - The URL of the faucet to use for funding accounts.
+   *
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+   *
+   * async function runExample() {
+   *     // Create a new Aptos client with Testnet configuration
+   *     const config = new AptosConfig({ network: Network.TESTNET }); // Specify your own network if needed
+   *     const aptos = new Aptos(config);
+   *
+   *     console.log("Aptos client initialized:", aptos);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   * @group Experimental
+   * @experimental
+   */
+  constructor(readonly config: AptosConfig) {}
+
+  async viewBinary(args: {
+    payload: InputViewFunctionData;
+    options?: LedgerVersionArg & { convert?: undefined };
+  }): Promise<Uint8Array>;
+  async viewBinary<T extends {}>(args: {
+    payload: InputViewFunctionData;
+    options: LedgerVersionArg & { convert: (input: Uint8Array) => T };
+  }): Promise<T>;
+
+  /**
+   * Returns BCS encoded results of the view function.  It can also convert the results to a specific type, if a
+   * converter is provided.
+   *
+   * @experimental
+   * @group Experimental
+   * @param args
+   */
+  async viewBinary<T extends {} = Uint8Array>(args: {
+    payload: InputViewFunctionData;
+    options?: LedgerVersionArg & { convert?: (input: Uint8Array) => T };
+  }): Promise<Uint8Array | T> {
+    return viewBinary<T>({ ...args, aptosConfig: this.config });
+  }
+}

package/src/api/transaction.ts

@@ -25,6 +25,8 @@ import {
   getSigningMessage,
   publicPackageTransaction,
   rotateAuthKey,
+  rotateAuthKeyToMultiEd25519,
+  rotateAuthKeyWithVerificationTransaction,
   signAndSubmitAsFeePayer,
   signAndSubmitTransaction,
   signAsFeePayer,
@@ -36,13 +38,14 @@ import {
   InputGenerateTransactionOptions,
   InputGenerateTransactionPayloadData,
 } from "../transactions";
-import { AccountAddressInput, PrivateKeyInput } from "../core";
+import { AccountAddressInput, Ed25519PrivateKey } from "../core";
 import { Account } from "../account";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
 import { TransactionManagement } from "./transactionSubmission/management";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
+import { MultiEd25519Account } from "../account/MultiEd25519Account";
 
 /**
  * Represents a transaction in the Aptos blockchain,
@@ -506,10 +509,27 @@ export class Transaction {
    * ```
    * @group Transaction
    */
-  async rotateAuthKey(args: { fromAccount: Account; toNewPrivateKey: PrivateKeyInput }): Promise<TransactionResponse> {
+  async rotateAuthKey(args: {
+    fromAccount: Account;
+    toNewPrivateKey: Ed25519PrivateKey;
+  }): Promise<PendingTransactionResponse> {
     return rotateAuthKey({ aptosConfig: this.config, ...args });
   }
 
+  async rotateAuthKeyToMultiEd25519(args: {
+    fromAccount: Account;
+    multiEd25519Account: MultiEd25519Account;
+  }): Promise<PendingTransactionResponse> {
+    return rotateAuthKeyToMultiEd25519({ aptosConfig: this.config, ...args });
+  }
+
+  async rotateAuthKeyWithVerificationTransaction(args: {
+    fromAccount: Account;
+    toAccount: Account;
+  }): Promise<CommittedTransactionResponse> {
+    return rotateAuthKeyWithVerificationTransaction({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Sign a transaction that can later be submitted to the chain.
    * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.

package/src/api/transactionSubmission/build.ts

@@ -1,12 +1,19 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AccountAddressInput } from "../../core";
+import { AccountAddress, AccountAddressInput } from "../../core";
 import { generateTransaction } from "../../internal/transactionSubmission";
-import { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from "../../transactions";
+import {
+  InputGenerateTransactionPayloadData,
+  InputGenerateTransactionOptions,
+  AptosScriptComposer,
+  TransactionPayloadScript,
+  generateRawTransaction,
+} from "../../transactions";
 import { MultiAgentTransaction } from "../../transactions/instances/multiAgentTransaction";
 import { SimpleTransaction } from "../../transactions/instances/simpleTransaction";
 import { AptosConfig } from "../aptosConfig";
+import { Deserializer } from "../../bcs";
 
 /**
  * A class to handle all `Build` transaction operations.
@@ -96,6 +103,82 @@ export class Build {
     return generateTransaction({ aptosConfig: this.config, ...args });
   }
 
+  /**
+   * Build a transaction from a series of Move calls.
+   *
+   * This function allows you to create a transaction with a list of Move calls.
+   *
+   * Right now we only tested this logic with single signer and we will add support
+   * for mutli agent transactions if needed.
+   *
+   * @param args.sender - The sender account address.
+   * @param args.builder - The closure to construct the list of calls.
+   * @param args.options - Optional transaction configurations.
+   * @param args.withFeePayer - Whether there is a fee payer for the transaction.
+   *
+   * @returns SimpleTransaction
+   *
+   * @example
+   * ```typescript
+   * import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
+   *
+   * const config = new AptosConfig({ network: Network.TESTNET });
+   * const aptos = new Aptos(config);
+   *
+   * async function runExample() {
+   *   // Build a transaction from a chained series of Move calls.
+   *   const transaction = await aptos.transaction.build.scriptComposer({
+   *     sender: "0x1", // replace with a real sender account address
+   *     builder: builder: async (builder) => {
+   *       const coin = await builder.addBatchedCalls({
+   *          function: "0x1::coin::withdraw",
+   *          functionArguments: [CallArgument.new_signer(0), 1],
+   *          typeArguments: ["0x1::aptos_coin::AptosCoin"],
+   *        });
+   *
+   *        // Pass the returned value from the first function call to the second call
+   *        const fungibleAsset = await builder.addBatchedCalls({
+   *          function: "0x1::coin::coin_to_fungible_asset",
+   *          functionArguments: [coin[0]],
+   *          typeArguments: ["0x1::aptos_coin::AptosCoin"],
+   *        });
+   *
+   *        await builder.addBatchedCalls({
+   *          function: "0x1::primary_fungible_store::deposit",
+   *          functionArguments: [singleSignerED25519SenderAccount.accountAddress, fungibleAsset[0]],
+   *          typeArguments: [],
+   *        });
+   *        return builder;
+   *     },
+   *     options: {
+   *       gasUnitPrice: 100, // specify your own gas unit price if needed
+   *       maxGasAmount: 1000, // specify your own max gas amount if needed
+   *     },
+   *   });
+   *
+   *   console.log(transaction);
+   * }
+   * runExample().catch(console.error);
+   * ```
+   */
+  async scriptComposer(args: {
+    sender: AccountAddressInput;
+    builder: (builder: AptosScriptComposer) => Promise<AptosScriptComposer>;
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+  }): Promise<SimpleTransaction> {
+    const composer = new AptosScriptComposer(this.config);
+    await composer.init();
+    const builder = await args.builder(composer);
+    const bytes = builder.build();
+    const rawTxn = await generateRawTransaction({
+      aptosConfig: this.config,
+      payload: TransactionPayloadScript.load(new Deserializer(bytes)),
+      ...args,
+    });
+    return new SimpleTransaction(rawTxn, args.withFeePayer === true ? AccountAddress.ZERO : undefined);
+  }
+
   /**
    * Build a multi-agent transaction that allows multiple signers to authorize a transaction.
    *

package/src/client/core.ts

@@ -15,6 +15,7 @@ import { AptosApiError } from "../errors";
  * @param options.method - The HTTP method to use for the request.
  * @param options.body - The body of the request.
  * @param options.contentType - The content type of the request.
+ * @param options.acceptType - The accept type of the request.
  * @param options.params - The query parameters to include in the request.
  * @param options.overrides - Additional overrides for the request.
  * @param options.overrides.HEADERS - Custom headers to include in the request.
@@ -57,6 +58,62 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
   });
 }
 
+/**
+ * Sends a request using the specified options and returns the response.
+ *
+ * @param options - The options for the request.
+ * @param options.url - The URL to send the request to.
+ * @param options.method - The HTTP method to use for the request.
+ * @param options.body - The body of the request.
+ * @param options.contentType - The content type of the request.
+ * @param options.acceptType - The accept type of the request.
+ * @param options.params - The query parameters to include in the request.
+ * @param options.overrides - Additional overrides for the request.
+ * @param options.overrides.HEADERS - Custom headers to include in the request.
+ * @param options.overrides.AUTH_TOKEN - The authorization token for the request.
+ * @param options.overrides.API_KEY - The API key for the request.
+ * @param options.originMethod - The origin method for the request.
+ * @param client - The client used to make the request.
+ *
+ * @returns The response from the request.
+ * @group Implementation
+ * @category Client
+ */
+export async function binaryRequest<Req>(options: ClientRequest<Req>, client: Client): Promise<ClientResponse<Buffer>> {
+  if (client.binaryProvider === undefined) {
+    throw new Error("Binary provider is not provided");
+  }
+  const { url, method, body, contentType, acceptType, params, overrides, originMethod } = options;
+  const headers: Record<string, string | AnyNumber | boolean | undefined> = {
+    ...overrides?.HEADERS,
+    "x-aptos-client": `aptos-typescript-sdk/${VERSION}`,
+    "content-type": contentType ?? MimeType.JSON,
+    accept: acceptType ?? MimeType.BCS,
+    "x-aptos-typescript-sdk-origin-method": originMethod,
+  };
+
+  if (overrides?.AUTH_TOKEN) {
+    headers.Authorization = `Bearer ${overrides?.AUTH_TOKEN}`;
+  }
+  if (overrides?.API_KEY) {
+    headers.Authorization = `Bearer ${overrides?.API_KEY}`;
+  }
+
+  /*
+   * make a call using the @aptos-labs/aptos-client package
+   * {@link https://www.npmjs.com/package/@aptos-labs/aptos-client}
+   */
+  return client.binaryProvider<Req>({
+    acceptType: MimeType.BCS,
+    url,
+    method,
+    body,
+    params,
+    headers,
+    overrides,
+  });
+}
+
 /**
  * The main function to use when making an API request, returning the response or throwing an AptosApiError on failure.
  *
@@ -118,3 +175,66 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
   // comes from an indexer request (e.g. 404), we'll need to mention it appropriately
   throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
 }
+
+/**
+ * The main function to use when making an API request, returning the response or throwing an AptosApiError on failure.
+ *
+ * @param aptosRequestOpts - Options for the Aptos request, including the URL and path.
+ * @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
+ * @experimental
+ */
+export async function aptosBinaryRequest<Req extends {}>(
+  aptosRequestOpts: AptosRequest,
+  aptosConfig: AptosConfig,
+  apiType: AptosApiType,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { url, path } = aptosRequestOpts;
+  const fullUrl = path ? `${url}/${path}` : url;
+  const clientResponse = await binaryRequest<Req>({ ...aptosRequestOpts, url: fullUrl }, aptosConfig.client);
+
+  const aptosResponse: AptosResponse<Req, Buffer> = {
+    status: clientResponse.status,
+    statusText: clientResponse.statusText ?? "No status text provided",
+    data: clientResponse.data,
+    headers: clientResponse.headers,
+    config: clientResponse.config,
+    request: clientResponse.request,
+    url: fullUrl,
+  };
+
+  // Handle case for `Unauthorized` error (i.e. API_KEY error)
+  if (aptosResponse.status === 401) {
+    throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
+  }
+
+  // to support both fullnode and indexer responses,
+  // check if it is an indexer query, and adjust response.data
+  if (apiType === AptosApiType.INDEXER) {
+    const indexerResponse = aptosResponse.data as any;
+    // Handle Indexer general errors
+    if (indexerResponse.errors) {
+      throw new AptosApiError({
+        apiType,
+        aptosRequest: aptosRequestOpts,
+        aptosResponse,
+      });
+    }
+    aptosResponse.data = indexerResponse.data as Buffer;
+  } else if (apiType === AptosApiType.PEPPER || apiType === AptosApiType.PROVER) {
+    if (aptosResponse.status >= 400) {
+      throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
+    }
+  }
+
+  if (aptosResponse.status >= 200 && aptosResponse.status < 300) {
+    return aptosResponse;
+  }
+
+  // We have to explicitly check for all request types, because if the error is a non-indexer error, but
+  // comes from an indexer request (e.g. 404), we'll need to mention it appropriately
+  throw new AptosApiError({ apiType, aptosRequest: aptosRequestOpts, aptosResponse });
+}

package/src/client/get.ts

@@ -1,5 +1,5 @@
 import { AptosConfig } from "../api/aptosConfig";
-import { aptosRequest } from "./core";
+import { aptosBinaryRequest, aptosRequest } from "./core";
 import { AptosResponse, AnyNumber, ClientConfig, MimeType } from "../types";
 import { AptosApiType } from "../utils/const";
 
@@ -107,6 +107,46 @@ export async function get<Req extends {}, Res extends {}>(
   );
 }
 
+/**
+ * Executes a GET request to retrieve data based on the provided options.
+ *
+ * @param options - The options for the GET request.
+ * @param options.aptosConfig - The configuration object for Aptos requests.
+ * @param options.overrides - Optional overrides for the request configuration.
+ * @param options.params - Query parameters to include in the request.
+ * @param options.contentType - The content type of the request.
+ * @param options.acceptType - The accepted response type.
+ * @param options.path - The specific path for the request.
+ * @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
+ * @experimental
+ */
+export async function getBinary<Req extends {}>(options: GetRequestOptions): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;
+  const url = aptosConfig.getRequestUrl(type);
+
+  return aptosBinaryRequest<Req>(
+    {
+      url,
+      method: "GET",
+      originMethod,
+      path,
+      contentType,
+      acceptType,
+      params,
+      overrides: {
+        ...aptosConfig.clientConfig,
+        ...overrides,
+      },
+    },
+    aptosConfig,
+    options.type,
+  );
+}
+
 /**
  * Retrieves data from the Aptos full node using the provided options.
  *
@@ -138,6 +178,38 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+/**
+ * Retrieves data from the Aptos full node using the provided options.
+ *
+ * @param options - The options for the request to the Aptos full node.
+ * @param options.aptosConfig - Configuration settings specific to the Aptos client and full node.
+ * @param options.aptosConfig.clientConfig - The client configuration settings.
+ * @param options.aptosConfig.fullnodeConfig - The full node configuration settings.
+ * @param options.overrides - Additional overrides for the request.
+ * @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
+ * @experimental
+ */
+export async function getBinaryAptosFullNode<Req extends {}>(
+  options: GetAptosRequestOptions,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig } = options;
+
+  return getBinary<Req>({
+    ...options,
+    type: AptosApiType.FULLNODE,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },
+    },
+  });
+}
+
 /**
  * Makes a GET request to the Aptos Pepper service to retrieve data.
  *