@aptos-labs/ts-sdk 1.31.0 → 1.32.0

package/src/internal/account.ts

@@ -7,13 +7,8 @@
  * other namespaces and processes can access these methods without depending on the entire
  * account namespace and without having a dependency cycle error.
  */
-
 import { AptosConfig } from "../api/aptosConfig";
-import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
-import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Account } from "../account";
-import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
-import { queryIndexer } from "./general";
+import { getAptosFullNode, paginateWithCursor } from "../client";
 import {
   AccountData,
   GetAccountCoinsDataResponse,
@@ -31,6 +26,10 @@ import {
   TransactionResponse,
   WhereArg,
 } from "../types";
+import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
+import { Account } from "../account";
+import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
+import { queryIndexer } from "./general";
 import {
   GetAccountCoinsCountQuery,
   GetAccountCoinsDataQuery,
@@ -56,6 +55,7 @@ import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObject
 import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 import { getTableItem } from "./table";
 import { APTOS_COIN } from "../utils";
+import { AptosApiError } from "../errors";
 
 /**
  * Retrieves account information for a specified account address.

package/src/internal/ans.ts

@@ -106,7 +106,8 @@ export function isActiveANSName(name: GetANSNameResponse[0]): boolean {
 }
 
 export const LOCAL_ANS_ACCOUNT_PK =
-  process.env.ANS_TEST_ACCOUNT_PRIVATE_KEY ?? "0x37368b46ce665362562c6d1d4ec01a08c8644c488690df5a17e13ba163e20221";
+  process.env.ANS_TEST_ACCOUNT_PRIVATE_KEY ??
+  "ed25519-priv-0x37368b46ce665362562c6d1d4ec01a08c8644c488690df5a17e13ba163e20221";
 export const LOCAL_ANS_ACCOUNT_ADDRESS =
   process.env.ANS_TEST_ACCOUNT_ADDRESS ?? "0x585fc9f0f0c54183b039ffc770ca282ebd87307916c215a3e692f2f8e4305e82";
 

package/src/internal/keyless.ts

@@ -16,6 +16,7 @@ import {
   Groth16Zkp,
   Hex,
   KeylessPublicKey,
+  MoveJWK,
   ZeroKnowledgeSig,
   ZkProof,
   getKeylessConfig,
@@ -29,6 +30,7 @@ import { FederatedKeylessAccount } from "../account/FederatedKeylessAccount";
 import { MoveVector } from "../bcs";
 import { generateTransaction } from "./transactionSubmission";
 import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions";
+import { KeylessError, KeylessErrorType } from "../errors";
 
 /**
  * Retrieves a pepper value based on the provided configuration and authentication details.
@@ -86,12 +88,19 @@ export async function getProof(args: {
   ephemeralKeyPair: EphemeralKeyPair;
   pepper?: HexInput;
   uidKey?: string;
+  maxExpHorizonSecs?: number;
 }): Promise<ZeroKnowledgeSig> {
-  const { aptosConfig, jwt, ephemeralKeyPair, pepper = await getPepper(args), uidKey = "sub" } = args;
+  const {
+    aptosConfig,
+    jwt,
+    ephemeralKeyPair,
+    pepper = await getPepper(args),
+    uidKey = "sub",
+    maxExpHorizonSecs = (await getKeylessConfig({ aptosConfig })).maxExpHorizonSecs,
+  } = args;
   if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {
     throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
   }
-  const { maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
   const decodedJwt = jwtDecode<JwtPayload>(jwt);
   if (typeof decodedJwt.iat !== "number") {
     throw new Error("iat was not found");
@@ -174,7 +183,9 @@ export async function deriveKeylessAccount(args: {
   proofFetchCallback?: ProofFetchCallback;
 }): Promise<KeylessAccount | FederatedKeylessAccount> {
   const { aptosConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
-  const proofPromise = getProof({ ...args, pepper });
+  const { verificationKey, maxExpHorizonSecs } = await getKeylessConfig({ aptosConfig });
+
+  const proofPromise = getProof({ ...args, pepper, maxExpHorizonSecs });
   // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the
   // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch
   // allowing for faster rendering of UX.
@@ -190,7 +201,15 @@ export async function deriveKeylessAccount(args: {
       authenticationKey: publicKey.authKey().derivedAddress(),
     });
 
-    return FederatedKeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback, jwkAddress });
+    return FederatedKeylessAccount.create({
+      ...args,
+      address,
+      proof,
+      pepper,
+      proofFetchCallback,
+      jwkAddress,
+      verificationKey,
+    });
   }
 
   const publicKey = KeylessPublicKey.fromJwtAndPepper({ jwt, pepper, uidKey });
@@ -198,19 +217,11 @@ export async function deriveKeylessAccount(args: {
     aptosConfig,
     authenticationKey: publicKey.authKey().derivedAddress(),
   });
-  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback });
-}
-
-interface JWK {
-  kty: string; // Key type
-  kid: string; // Key ID
-  alg: string; // Algorithm used with the key
-  n: string; // Modulus (for RSA keys)
-  e: string; // Exponent (for RSA keys)
+  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback, verificationKey });
 }
 
-interface JWKS {
-  keys: JWK[];
+export interface JWKS {
+  keys: MoveJWK[];
 }
 
 export async function updateFederatedKeylessJwkSetTransaction(args: {
@@ -222,10 +233,27 @@ export async function updateFederatedKeylessJwkSetTransaction(args: {
 }): Promise<SimpleTransaction> {
   const { aptosConfig, sender, iss, options } = args;
   const jwksUrl = args.jwksUrl ?? (iss.endsWith("/") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`);
-  const response = await fetch(jwksUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch JWKS: ${response.status} ${response.statusText}`);
+
+  let response: Response;
+
+  try {
+    response = await fetch(jwksUrl);
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+  } catch (error) {
+    let errorMessage: string;
+    if (error instanceof Error) {
+      errorMessage = `${error.message}`;
+    } else {
+      errorMessage = `error unknown - ${error}`;
+    }
+    throw KeylessError.fromErrorType({
+      type: KeylessErrorType.JWK_FETCH_FAILED_FEDERATED,
+      details: `Failed to fetch JWKS at ${jwksUrl}: ${errorMessage}`,
+    });
   }
+
   const jwks: JWKS = await response.json();
   return generateTransaction({
     aptosConfig,

package/src/internal/transaction.ts

@@ -9,7 +9,8 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
+import { getAptosFullNode, paginateWithCursor } from "../client";
+import { AptosApiError } from "../errors";
 import {
   TransactionResponseType,
   type AnyNumber,

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