@aptos-labs/ts-sdk 1.30.0 → 1.32.0

package/src/internal/transactionSubmission.ts

@@ -6,11 +6,11 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { MoveVector, U8 } from "../bcs";
+import { Deserializer, MoveVector, U8 } from "../bcs";
 import { postAptosFullNode } from "../client";
-import { Account, AbstractKeylessAccount, MultiKeyAccount } from "../account";
+import { Account, AbstractKeylessAccount, isKeylessSigner } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { PrivateKey } from "../core/crypto";
+import { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature, PrivateKey } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
 import { RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
 import {
@@ -33,7 +33,7 @@ import {
 } from "../transactions/types";
 import { getInfo } from "./account";
 import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
-import { TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
+import { SignedTransaction, TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
 
@@ -312,15 +312,33 @@ export async function submitTransaction(
 ): Promise<PendingTransactionResponse> {
   const { aptosConfig } = args;
   const signedTransaction = generateSignedTransaction({ ...args });
-  const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({
-    aptosConfig,
-    body: signedTransaction,
-    path: "transactions",
-    originMethod: "submitTransaction",
-    contentType: MimeType.BCS_SIGNED_TRANSACTION,
-  });
-  return data;
+  try {
+    const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({
+      aptosConfig,
+      body: signedTransaction,
+      path: "transactions",
+      originMethod: "submitTransaction",
+      contentType: MimeType.BCS_SIGNED_TRANSACTION,
+    });
+    return data;
+  } catch (e) {
+    const signedTxn = SignedTransaction.deserialize(new Deserializer(signedTransaction));
+    if (
+      signedTxn.authenticator.isSingleSender() &&
+      signedTxn.authenticator.sender.isSingleKey() &&
+      (signedTxn.authenticator.sender.public_key.publicKey instanceof KeylessPublicKey ||
+        signedTxn.authenticator.sender.public_key.publicKey instanceof FederatedKeylessPublicKey)
+    ) {
+      await AbstractKeylessAccount.fetchJWK({
+        aptosConfig,
+        publicKey: signedTxn.authenticator.sender.public_key.publicKey,
+        kid: (signedTxn.authenticator.sender.signature.signature as KeylessSignature).getJwkKid(),
+      });
+    }
+    throw e;
+  }
 }
+
 export type FeePayerOrFeePayerAuthenticatorOrNeither =
   | { feePayer: Account; feePayerAuthenticator?: never }
   | { feePayer?: never; feePayerAuthenticator: AccountAuthenticator }
@@ -336,11 +354,11 @@ export async function signAndSubmitTransaction(
   const { aptosConfig, signer, feePayer, transaction } = args;
   // If the signer contains a KeylessAccount, await proof fetching in case the proof
   // was fetched asynchronously.
-  if (signer instanceof AbstractKeylessAccount || signer instanceof MultiKeyAccount) {
-    await signer.waitForProofFetch();
+  if (isKeylessSigner(signer)) {
+    await signer.checkKeylessAccountValidity(aptosConfig);
   }
-  if (feePayer instanceof AbstractKeylessAccount || feePayer instanceof MultiKeyAccount) {
-    await feePayer.waitForProofFetch();
+  if (isKeylessSigner(feePayer)) {
+    await feePayer.checkKeylessAccountValidity(aptosConfig);
   }
   const feePayerAuthenticator =
     args.feePayerAuthenticator || (feePayer && signAsFeePayer({ signer: feePayer, transaction }));
@@ -362,8 +380,8 @@ export async function signAndSubmitAsFeePayer(args: {
 }): Promise<PendingTransactionResponse> {
   const { aptosConfig, senderAuthenticator, feePayer, transaction } = args;
 
-  if (feePayer instanceof AbstractKeylessAccount || feePayer instanceof MultiKeyAccount) {
-    await feePayer.waitForProofFetch();
+  if (isKeylessSigner(feePayer)) {
+    await feePayer.checkKeylessAccountValidity(aptosConfig);
   }
 
   const feePayerAuthenticator = signAsFeePayer({ signer: feePayer, transaction });

package/src/transactions/authenticator/transaction.ts

@@ -42,6 +42,26 @@ export abstract class TransactionAuthenticator extends Serializable {
         throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
     }
   }
+
+  isEd25519(): this is TransactionAuthenticatorEd25519 {
+    return this instanceof TransactionAuthenticatorEd25519;
+  }
+
+  isMultiEd25519(): this is TransactionAuthenticatorMultiEd25519 {
+    return this instanceof TransactionAuthenticatorMultiEd25519;
+  }
+
+  isMultiAgent(): this is TransactionAuthenticatorMultiAgent {
+    return this instanceof TransactionAuthenticatorMultiAgent;
+  }
+
+  isFeePayer(): this is TransactionAuthenticatorFeePayer {
+    return this instanceof TransactionAuthenticatorFeePayer;
+  }
+
+  isSingleSender(): this is TransactionAuthenticatorSingleSender {
+    return this instanceof TransactionAuthenticatorSingleSender;
+  }
 }
 
 /**

package/src/transactions/index.ts

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

package/src/transactions/script-composer/index.ts

@@ -0,0 +1,76 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionComposer, initSync, wasm } from "@wgb5445/aptos-intent-npm";
+import { AptosApiType } from "../../utils";
+import { AptosConfig } from "../../api/aptosConfig";
+import { InputBatchedFunctionData } from "../types";
+import { fetchMoveFunctionAbi, getFunctionParts, standardizeTypeTags } from "../transactionBuilder";
+import { CallArgument } from "../../types";
+import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+
+(async () => {
+  initSync({ module: wasm });
+})();
+
+// 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 builder: TransactionComposer;
+
+  private config: AptosConfig;
+
+  constructor(aptosConfig: AptosConfig) {
+    this.builder = TransactionComposer.single_signer();
+    this.config = aptosConfig;
+  }
+
+  // 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) {
+      for (const typeTag of input.typeArguments) {
+        // eslint-disable-next-line no-await-in-loop
+        await 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);
+  }
+}

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -45,7 +45,7 @@ import {
   throwTypeMismatch,
   convertNumber,
 } from "./helpers";
-import { MoveFunction } from "../../types";
+import { CallArgument, MoveFunction } from "../../types";
 
 const TEXT_ENCODER = new TextEncoder();
 
@@ -92,6 +92,34 @@ export async function fetchFunctionAbi(
   return undefined;
 }
 
+/**
+ * Fetches a function ABI from the on-chain module ABI.  It doesn't validate whether it's a view or entry function.
+ * @param moduleAddress
+ * @param moduleName
+ * @param functionName
+ * @param aptosConfig
+ */
+export async function fetchMoveFunctionAbi(
+  moduleAddress: string,
+  moduleName: string,
+  functionName: string,
+  aptosConfig: AptosConfig,
+): Promise<FunctionABI> {
+  const functionAbi = await fetchFunctionAbi(moduleAddress, moduleName, functionName, aptosConfig);
+  if (!functionAbi) {
+    throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+  }
+  const params: TypeTag[] = [];
+  for (let i = 0; i < functionAbi.params.length; i += 1) {
+    params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
+  }
+
+  return {
+    typeParameters: functionAbi.generic_type_params,
+    parameters: params,
+  };
+}
+
 /**
  * Fetches the ABI for an entry function from the specified module address.
  * This function validates if the ABI corresponds to an entry function and retrieves its parameters.
@@ -183,6 +211,32 @@ export async function fetchViewFunctionAbi(
   };
 }
 
+/**
+ * Converts a entry function argument into CallArgument, if necessary.
+ * This function checks the provided argument against the expected parameter type and converts it accordingly.
+ *
+ * @param functionName - The name of the function for which the argument is being converted.
+ * @param functionAbi - The ABI (Application Binary Interface) of the function, which defines its parameters.
+ * @param argument - The argument to be converted, which can be of various types. If the argument is already
+ *                   CallArgument returned from TransactionComposer it would be returned immediately.
+ * @param position - The index of the argument in the function's parameter list.
+ * @param genericTypeParams - An array of type tags for any generic type parameters.
+ */
+export function convertCallArgument(
+  argument: CallArgument | EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes,
+  functionName: string,
+  functionAbi: FunctionABI,
+  position: number,
+  genericTypeParams: Array<TypeTag>,
+): CallArgument {
+  if (argument instanceof CallArgument) {
+    return argument;
+  }
+  return CallArgument.new_bytes(
+    convertArgument(functionName, functionAbi, argument, position, genericTypeParams).bcsToBytes(),
+  );
+}
+
 /**
  * Converts a non-BCS encoded argument into BCS encoded, if necessary.
  * This function checks the provided argument against the expected parameter type and converts it accordingly.

package/src/transactions/types.ts

@@ -1,6 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
+import { CallArgument } from "@wgb5445/aptos-intent-npm";
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveOption, MoveString, MoveVector } from "../bcs/serializable/moveStructs";
 import { Bool, U128, U16, U256, U32, U64, U8 } from "../bcs/serializable/movePrimitives";
@@ -164,6 +165,16 @@ export type InputMultiSigDataWithABI = {
  * Combines input function data with Aptos configuration for remote ABI interactions.
  */
 export type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & { aptosConfig: AptosConfig };
+
+/**
+ * The data needed to generate a batched function payload
+ */
+export type InputBatchedFunctionData = {
+  function: MoveFunctionId;
+  typeArguments?: Array<TypeArgument>;
+  functionArguments: Array<EntryFunctionArgumentTypes | CallArgument | SimpleEntryFunctionArgumentTypes>;
+};
+
 /**
  * The data needed to generate a Multi Sig payload
  */