@aptos-labs/ts-sdk 1.33.2 → 1.35.0

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/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.
  *

package/src/client/post.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 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";
 
@@ -115,6 +115,45 @@ export async function post<Req extends {}, Res extends {}>(
   );
 }
 
+/**
+ * Executes a POST request to the specified URL with the provided options.
+ *
+ * @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.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function postBinary<Req extends {}>(options: PostRequestOptions): Promise<AptosResponse<Req, Buffer>> {
+  const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
+  const url = aptosConfig.getRequestUrl(type);
+
+  return aptosBinaryRequest<Req>(
+    {
+      url,
+      method: "POST",
+      originMethod,
+      path,
+      body,
+      contentType,
+      acceptType,
+      params,
+      overrides,
+    },
+    aptosConfig,
+    options.type,
+  );
+}
+
 /**
  * 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.
@@ -144,6 +183,36 @@ export async function postAptosFullNode<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.
+ * @group Implementation
+ * @category Client
+ * @experimental
+ */
+export async function postBinaryAptosFullNode<Req extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Buffer>> {
+  const { aptosConfig } = options;
+
+  return postBinary<Req>({
+    ...options,
+    type: AptosApiType.FULLNODE,
+    overrides: {
+      ...aptosConfig.clientConfig,
+      ...aptosConfig.fullnodeConfig,
+      ...options.overrides,
+      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS },
+    },
+  });
+}
+
 /**
  * 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.

package/src/core/crypto/abstraction.ts

@@ -0,0 +1,47 @@
+import { Deserializer, Serializer } from "../../bcs";
+import { HexInput } from "../../types";
+import { AccountAddress } from "../accountAddress";
+import { AuthenticationKey } from "../authenticationKey";
+import { Hex } from "../hex";
+import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { Signature } from "./signature";
+
+export class AbstractSignature extends Signature {
+  readonly value: Hex;
+
+  constructor(value: HexInput) {
+    super();
+    this.value = Hex.fromHexInput(value);
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeBytes(this.value.toUint8Array());
+  }
+
+  static deserialize(deserializer: Deserializer): AbstractSignature {
+    return new AbstractSignature(deserializer.deserializeBytes());
+  }
+}
+
+export class AbstractPublicKey extends AccountPublicKey {
+  readonly accountAddress: AccountAddress;
+
+  constructor(accountAddress: AccountAddress) {
+    super();
+    this.accountAddress = accountAddress;
+  }
+
+  authKey(): AuthenticationKey {
+    return new AuthenticationKey({ data: this.accountAddress.toUint8Array() });
+  }
+
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  verifySignature(args: VerifySignatureArgs): boolean {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  serialize(serializer: Serializer): void {
+    throw new Error("This function is not implemented for AbstractPublicKey.");
+  }
+}

package/src/core/crypto/multiEd25519.ts

@@ -5,7 +5,8 @@ import { Deserializer, Serializer } from "../../bcs";
 import { SigningScheme as AuthenticationKeyScheme } from "../../types";
 import { AuthenticationKey } from "../authenticationKey";
 import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
+import { AbstractMultiKey } from "./multiKey";
+import { VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 
 /**
@@ -19,7 +20,7 @@ import { Signature } from "./signature";
  * @group Implementation
  * @category Serialization
  */
-export class MultiEd25519PublicKey extends AccountPublicKey {
+export class MultiEd25519PublicKey extends AbstractMultiKey {
   /**
    * Maximum number of public keys supported
    * @group Implementation
@@ -69,8 +70,8 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
    * @category Serialization
    */
   constructor(args: { publicKeys: Ed25519PublicKey[]; threshold: number }) {
-    super();
     const { publicKeys, threshold } = args;
+    super({ publicKeys });
 
     // Validate number of public keys
     if (publicKeys.length > MultiEd25519PublicKey.MAX_KEYS || publicKeys.length < MultiEd25519PublicKey.MIN_KEYS) {
@@ -209,6 +210,21 @@ export class MultiEd25519PublicKey extends AccountPublicKey {
   }
 
   // endregion
+
+  /**
+   * Get the index of the provided public key.
+   *
+   * This function retrieves the index of a specified public key within the MultiKey.
+   * If the public key does not exist, it throws an error.
+   *
+   * @param publicKey - The public key to find the index for.
+   * @returns The corresponding index of the public key, if it exists.
+   * @throws Error - If the public key is not found in the MultiKey.
+   * @group Implementation
+   */
+  getIndex(publicKey: Ed25519PublicKey): number {
+    return super.getIndex(publicKey);
+  }
 }
 
 /**