@aptos-labs/ts-sdk 1.33.2 → 1.34.0

package/src/api/account/abstraction.ts

@@ -0,0 +1,239 @@
+import { AccountAddress, AccountAddressInput } from "../../core";
+import {
+  addAuthenticationFunctionTransaction,
+  removeAuthenticationFunctionTransaction,
+  removeDispatchableAuthenticatorTransaction,
+} from "../../internal/abstraction";
+import { view } from "../../internal/view";
+import { InputGenerateTransactionOptions, TypeTagAddress } from "../../transactions";
+import { MoveFunctionId } from "../../types";
+import { getFunctionParts } from "../../utils/helpers";
+import { AptosConfig } from "../aptosConfig";
+
+export class AccountAbstraction {
+  constructor(readonly config: AptosConfig) {}
+
+  /**
+   * Adds a dispatchable authentication function to the account.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.addAuthenticationFunctionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn =  await aptos.signAndSubmitTransaction({ signer: alice, transaction});
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to add the authentication function to.
+   * @param args.authenticationFunction - The authentication function info to add.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to add the authentication function to the account.
+   */
+  public async addAuthenticationFunctionTransaction(args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction: string;
+    options?: InputGenerateTransactionOptions;
+  }) {
+    const { accountAddress, authenticationFunction, options } = args;
+    return addAuthenticationFunctionTransaction({
+      aptosConfig: this.config,
+      authenticationFunction,
+      sender: accountAddress,
+      options,
+    });
+  }
+
+  /**
+   * Removes a dispatchable authentication function from the account.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.removeAuthenticationFunctionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to remove the authentication function from.
+   * @param args.authenticationFunction - The authentication function info to remove.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to remove the authentication function from the account.
+   */
+  public async removeAuthenticationFunctionTransaction(args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction: string;
+    options?: InputGenerateTransactionOptions;
+  }) {
+    const { accountAddress, authenticationFunction, options } = args;
+    return removeAuthenticationFunctionTransaction({
+      aptosConfig: this.config,
+      sender: accountAddress,
+      authenticationFunction,
+      options,
+    });
+  }
+
+  /**
+   * Removes a dispatchable authenticator from the account.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.removeDispatchableAuthenticatorTransaction({
+   *   accountAddress: alice.accountAddress,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to remove the authenticator from.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to remove the authenticator from the account.
+   */
+  public async removeDispatchableAuthenticatorTransaction(args: {
+    accountAddress: AccountAddressInput;
+    options?: InputGenerateTransactionOptions;
+  }) {
+    const { accountAddress, options } = args;
+    return removeDispatchableAuthenticatorTransaction({ aptosConfig: this.config, sender: accountAddress, options });
+  }
+
+  /**
+   * Gets the dispatchable authentication function for the account.
+   *
+   * @example
+   * ```ts
+   * const functionInfos = await aptos.abstraction.getAuthenticationFunction({
+   *   accountAddress: alice.accountAddress,
+   * });
+   *
+   * if (functionInfos) {
+   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
+   * } else {
+   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
+   * }
+   * ```
+   *
+   * @param args.accountAddress - The account to get the dispatchable authentication function for.
+   * @returns The dispatchable authentication function for the account.
+   */
+  public async getAuthenticationFunction(args: { accountAddress: AccountAddressInput }) {
+    const { accountAddress } = args;
+    const [{ vec: functionInfoOption }] = await view<
+      [{ vec: { function_name: string; module_name: string; module_address: string }[][] }]
+    >({
+      aptosConfig: this.config,
+      payload: {
+        function: "0x1::account_abstraction::dispatchable_authenticator",
+        functionArguments: [AccountAddress.from(accountAddress)],
+        abi: { typeParameters: [], parameters: [new TypeTagAddress()], returnTypes: [] },
+      },
+    });
+
+    if (functionInfoOption.length === 0) return undefined;
+
+    return functionInfoOption[0].map((functionInfo) => ({
+      moduleAddress: AccountAddress.fromString(functionInfo.module_address),
+      moduleName: functionInfo.module_name,
+      functionName: functionInfo.function_name,
+    }));
+  }
+
+  /**
+   * Will return true if the account is abstracted, otherwise false.
+   *
+   * @example
+   * ```ts
+   * const isAccountAbstractionEnabled = await aptos.abstraction.isAccountAbstractionEnabled({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   * if (isAccountAbstractionEnabled) {
+   *   console.log(`Account ${alice.accountAddress.toString()} is using account abstraction!`);
+   * } else {
+   *   console.log(`Account ${alice.accountAddress.toString()} is not using account abstraction.`);
+   * }
+   * ```
+   *
+   * @param args.accountAddress - The account to check.
+   * @returns Whether the account is abstracted.
+   */
+  public isAccountAbstractionEnabled = async (args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction: string;
+  }) => {
+    const functionInfos = await this.getAuthenticationFunction(args);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(args.authenticationFunction as MoveFunctionId);
+    return (
+      functionInfos?.some(
+        (functionInfo) =>
+          AccountAddress.fromString(moduleAddress).equals(functionInfo.moduleAddress) &&
+          moduleName === functionInfo.moduleName &&
+          functionName === functionInfo.functionName,
+      ) ?? false
+    );
+  };
+
+  /**
+   * Creates a transaction to enable account abstraction with the given authentication function.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.enableAccountAbstractionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `{alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to enable account abstraction for.
+   * @param args.authenticationFunction - The authentication function info to use.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to enable account abstraction for the account.
+   */
+  public enableAccountAbstractionTransaction = this.addAuthenticationFunctionTransaction;
+
+  /**
+   * Creates a transaction to disable account abstraction. If an authentication function is provided, it will specify to
+   * remove the authentication function.
+   *
+   * @example
+   * ```ts
+   * const txn = await aptos.abstraction.disableAccountAbstractionTransaction({
+   *   accountAddress: alice.accountAddress,
+   *   authenticationFunction: `${alice.accountAddress}::any_authenticator::authenticate`,
+   * });
+   *
+   * const txn = await aptos.signAndSubmitTransaction({ signer: alice, transaction: txn });
+   * await aptos.waitForTransaction({ transactionHash: txn.hash });
+   * ```
+   *
+   * @param args.accountAddress - The account to disable account abstraction for.
+   * @param args.authenticationFunction - The authentication function info to remove.
+   * @param args.options - The options for the transaction.
+   * @returns A transaction to disable account abstraction for the account.
+   */
+  public disableAccountAbstractionTransaction = async (args: {
+    accountAddress: AccountAddressInput;
+    authenticationFunction?: string;
+    options?: InputGenerateTransactionOptions;
+  }) => {
+    const { accountAddress, authenticationFunction, options } = args;
+    if (authenticationFunction) {
+      return this.removeAuthenticationFunctionTransaction({
+        accountAddress,
+        authenticationFunction,
+        options,
+      });
+    }
+    return this.removeDispatchableAuthenticatorTransaction({ accountAddress, options });
+  };
+}

package/src/api/account.ts

@@ -47,12 +47,15 @@ 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";
 
 /**
  * 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 +76,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.

package/src/api/aptos.ts

@@ -15,6 +15,7 @@ import { Transaction } from "./transaction";
 import { Table } from "./table";
 import { Keyless } from "./keyless";
 import { AptosObject } from "./object";
+import { AccountAbstraction } from "./account/abstraction";
 
 /**
  * The main entry point for interacting with the Aptos APIs,
@@ -94,6 +95,7 @@ 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);
@@ -149,6 +151,7 @@ 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");

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/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/internal/abstraction.ts

@@ -0,0 +1,79 @@
+import {
+  SimpleTransaction,
+  InputGenerateTransactionOptions,
+  TypeTagAddress,
+  TypeTagStruct,
+  stringStructTag,
+} from "../transactions";
+import { AccountAddressInput } from "../core";
+import { generateTransaction } from "./transactionSubmission";
+import { MoveFunctionId } from "../types";
+import { AptosConfig } from "../api/aptosConfig";
+import { getFunctionParts } from "../utils/helpers";
+
+export async function addAuthenticationFunctionTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  authenticationFunction: string;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SimpleTransaction> {
+  const { aptosConfig, sender, authenticationFunction, options } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::add_authentication_function",
+      typeArguments: [],
+      functionArguments: [moduleAddress, moduleName, functionName],
+      abi: {
+        typeParameters: [],
+        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],
+      },
+    },
+    options,
+  });
+}
+
+export async function removeAuthenticationFunctionTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  authenticationFunction: string;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, authenticationFunction, options } = args;
+  const { moduleAddress, moduleName, functionName } = getFunctionParts(authenticationFunction as MoveFunctionId);
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::remove_authentication_function",
+      typeArguments: [],
+      functionArguments: [moduleAddress, moduleName, functionName],
+      abi: {
+        typeParameters: [],
+        parameters: [new TypeTagAddress(), new TypeTagStruct(stringStructTag()), new TypeTagStruct(stringStructTag())],
+      },
+    },
+    options,
+  });
+}
+
+export async function removeDispatchableAuthenticatorTransaction(args: {
+  aptosConfig: AptosConfig;
+  sender: AccountAddressInput;
+  options?: InputGenerateTransactionOptions;
+}) {
+  const { aptosConfig, sender, options } = args;
+  return generateTransaction({
+    aptosConfig,
+    sender,
+    data: {
+      function: "0x1::account_abstraction::remove_authenticator",
+      typeArguments: [],
+      functionArguments: [],
+      abi: { typeParameters: [], parameters: [] },
+    },
+    options,
+  });
+}

package/src/transactions/authenticator/account.ts

@@ -8,7 +8,10 @@ import { AnyPublicKey, AnySignature } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
 import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
 import { MultiKey, MultiKeySignature } from "../../core/crypto/multiKey";
-import { AccountAuthenticatorVariant } from "../../types";
+import { AccountAuthenticatorVariant, HexInput, MoveFunctionId } from "../../types";
+import { AbstractionAuthDataVariant } from "../../types/abstraction";
+import { AccountAddress, Hex } from "../../core";
+import { getFunctionParts, isValidFunctionInfo } from "../../utils/helpers";
 
 /**
  * Represents an account authenticator that can handle multiple authentication variants.
@@ -43,6 +46,8 @@ export abstract class AccountAuthenticator extends Serializable {
         return AccountAuthenticatorMultiKey.load(deserializer);
       case AccountAuthenticatorVariant.NoAccountAuthenticator:
         return AccountAuthenticatorNoAccountAuthenticator.load(deserializer);
+      case AccountAuthenticatorVariant.Abstraction:
+        return AccountAuthenticatorAbstraction.load(deserializer);
       default:
         throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
     }
@@ -263,3 +268,49 @@ export class AccountAuthenticatorNoAccountAuthenticator extends AccountAuthentic
     return new AccountAuthenticatorNoAccountAuthenticator();
   }
 }
+
+export class AccountAuthenticatorAbstraction extends AccountAuthenticator {
+  public readonly functionInfo: string;
+
+  public readonly signingMessageDigest: Hex;
+
+  public readonly authenticator: Hex;
+
+  constructor(functionInfo: string, signingMessageDigest: HexInput, authenticator: HexInput) {
+    super();
+    if (!isValidFunctionInfo(functionInfo)) {
+      throw new Error(`Invalid function info ${functionInfo} passed into AccountAuthenticatorAbstraction`);
+    }
+    this.functionInfo = functionInfo;
+    this.authenticator = Hex.fromHexInput(authenticator);
+    this.signingMessageDigest = Hex.fromHexInput(Hex.fromHexInput(signingMessageDigest).toUint8Array());
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Abstraction);
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(this.functionInfo as MoveFunctionId);
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+    serializer.serializeU32AsUleb128(AbstractionAuthDataVariant.V1);
+    serializer.serializeBytes(this.signingMessageDigest.toUint8Array());
+    serializer.serializeFixedBytes(this.authenticator.toUint8Array());
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorAbstraction {
+    const moduleAddress = AccountAddress.deserialize(deserializer);
+    const moduleName = deserializer.deserializeStr();
+    const functionName = deserializer.deserializeStr();
+    const variant = deserializer.deserializeUleb128AsU32();
+    if (variant === AbstractionAuthDataVariant.V1) {
+      const signingMessageDigest = deserializer.deserializeBytes();
+      const authenticator = deserializer.deserializeFixedBytes(deserializer.remaining());
+      return new AccountAuthenticatorAbstraction(
+        `${moduleAddress}::${moduleName}::${functionName}`,
+        signingMessageDigest,
+        authenticator,
+      );
+    }
+    throw new Error(`Unknown variant index for AccountAuthenticatorAbstraction: ${variant}`);
+  }
+}

package/src/transactions/index.ts

@@ -7,3 +7,4 @@ export * from "./transactionBuilder";
 export * from "./typeTag";
 export * from "./typeTag/parser";
 export * from "./types";
+export * from "./scriptComposer";

package/src/transactions/scriptComposer/index.ts

@@ -0,0 +1,87 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { ScriptComposerWasm } from "@aptos-labs/script-composer-pack";
+import { AptosApiType, getFunctionParts } from "../../utils";
+import { AptosConfig } from "../../api/aptosConfig";
+import { InputBatchedFunctionData } from "../types";
+import { fetchMoveFunctionAbi, standardizeTypeTags } from "../transactionBuilder";
+import { CallArgument } from "../../types";
+import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+
+/**
+ * A wrapper class around TransactionComposer, which is a WASM library compiled
+ * from aptos-core/aptos-move/script-composer.
+ * This class allows the SDK caller to build a transaction that invokes multiple Move functions
+ * and allow for arguments to be passed around.
+ * */
+export class AptosScriptComposer {
+  private config: AptosConfig;
+
+  private builder?: any;
+
+  private static transactionComposer?: any;
+
+  constructor(aptosConfig: AptosConfig) {
+    this.config = aptosConfig;
+    this.builder = undefined;
+  }
+
+  // Initializing the wasm needed for the script composer, must be called
+  // before using the composer.
+  async init() {
+    if (!AptosScriptComposer.transactionComposer) {
+      const module = await import("@aptos-labs/script-composer-pack");
+      const { TransactionComposer, initSync } = module;
+      if (!ScriptComposerWasm.isInitialized) {
+        ScriptComposerWasm.init();
+      }
+      initSync({ module: ScriptComposerWasm.wasm });
+      AptosScriptComposer.transactionComposer = TransactionComposer;
+    }
+    this.builder = AptosScriptComposer.transactionComposer.single_signer();
+  }
+
+  // Add a move function invocation to the TransactionComposer.
+  //
+  // Similar to how to create an entry function, the difference is that input arguments could
+  // either be a `CallArgument` which represents an abstract value returned from a previous Move call
+  // or the regular entry function arguments.
+  //
+  // The function would also return a list of `CallArgument` that can be passed on to future calls.
+  async addBatchedCalls(input: InputBatchedFunctionData): Promise<CallArgument[]> {
+    const { moduleAddress, moduleName, functionName } = getFunctionParts(input.function);
+    const nodeUrl = this.config.getRequestUrl(AptosApiType.FULLNODE);
+
+    // Load the calling module into the builder.
+    await this.builder.load_module(nodeUrl, `${moduleAddress}::${moduleName}`);
+
+    // Load the calling type arguments into the loader.
+    if (input.typeArguments !== undefined) {
+      await Promise.all(input.typeArguments.map((typeTag) => this.builder.load_type_tag(nodeUrl, typeTag.toString())));
+    }
+    const typeArguments = standardizeTypeTags(input.typeArguments);
+    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    // Check the type argument count against the ABI
+    if (typeArguments.length !== functionAbi.typeParameters.length) {
+      throw new Error(
+        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,
+      );
+    }
+
+    const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>
+      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),
+    );
+
+    return this.builder.add_batched_call(
+      `${moduleAddress}::${moduleName}`,
+      functionName,
+      typeArguments.map((arg) => arg.toString()),
+      functionArguments,
+    );
+  }
+
+  build(): Uint8Array {
+    return this.builder.generate_batched_calls(true);
+  }
+}