@aptos-labs/ts-sdk 1.35.0 → 1.36.0

package/src/internal/account.ts

@@ -23,14 +23,16 @@ import {
   MoveStructId,
   OrderByArg,
   PaginationArgs,
+  PendingTransactionResponse,
   TokenStandardArg,
   TransactionResponse,
   WhereArg,
 } from "../types";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { Account } from "../account";
+import { Account, Ed25519Account, MultiEd25519Account } from "../account";
 import { AnyPublicKey, Ed25519PublicKey, PrivateKey } from "../core/crypto";
 import { queryIndexer } from "./general";
+import { getModules as getModulesUtil, getModule as getModuleUtil, getInfo as getInfoUtil } from "./utils";
 import {
   GetAccountCoinsCountQuery,
   GetAccountCoinsDataQuery,
@@ -51,12 +53,15 @@ import {
   GetAccountTokensCount,
   GetAccountTransactionsCount,
 } from "../types/generated/queries";
-import { memoizeAsync } from "../utils/memoize";
 import { Secp256k1PrivateKey, AuthenticationKey, Ed25519PrivateKey, createObjectAddress } from "../core";
 import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 import { getTableItem } from "./table";
 import { APTOS_COIN } from "../utils";
 import { AptosApiError } from "../errors";
+import { signAndSubmitTransaction, generateTransaction } from "./transactionSubmission";
+import { EntryFunctionABI, RotationProofChallenge, TypeTagU8, TypeTagVector } from "../transactions";
+import { U8, MoveVector } from "../bcs";
+import { waitForTransaction } from "./transaction";
 
 /**
  * Retrieves account information for a specified account address.
@@ -70,13 +75,7 @@ export async function getInfo(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
 }): Promise<AccountData> {
-  const { aptosConfig, accountAddress } = args;
-  const { data } = await getAptosFullNode<{}, AccountData>({
-    aptosConfig,
-    originMethod: "getInfo",
-    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,
-  });
-  return data;
+  return getInfoUtil(args);
 }
 
 /**
@@ -96,17 +95,7 @@ export async function getModules(args: {
   accountAddress: AccountAddressInput;
   options?: PaginationArgs & LedgerVersionArg;
 }): Promise<MoveModuleBytecode[]> {
-  const { aptosConfig, accountAddress, options } = args;
-  return paginateWithObfuscatedCursor<{}, MoveModuleBytecode[]>({
-    aptosConfig,
-    originMethod: "getModules",
-    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
-    params: {
-      ledger_version: options?.ledgerVersion,
-      offset: options?.offset,
-      limit: options?.limit ?? 1000,
-    },
-  });
+  return getModulesUtil(args);
 }
 
 /**
@@ -128,45 +117,7 @@ export async function getModule(args: {
   moduleName: string;
   options?: LedgerVersionArg;
 }): Promise<MoveModuleBytecode> {
-  // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled
-  // by the developer directly
-  if (args.options?.ledgerVersion !== undefined) {
-    return getModuleInner(args);
-  }
-
-  return memoizeAsync(
-    async () => getModuleInner(args),
-    `module-${args.accountAddress}-${args.moduleName}`,
-    1000 * 60 * 5, // 5 minutes
-  )();
-}
-
-/**
- * Retrieves the bytecode of a specified module from a given account address.
- *
- * @param args - The parameters for retrieving the module bytecode.
- * @param args.aptosConfig - The configuration for connecting to the Aptos network.
- * @param args.accountAddress - The address of the account from which to retrieve the module.
- * @param args.moduleName - The name of the module to retrieve.
- * @param args.options - Optional parameters for specifying the ledger version.
- * @param args.options.ledgerVersion - The specific ledger version to query.
- * @group Implementation
- */
-async function getModuleInner(args: {
-  aptosConfig: AptosConfig;
-  accountAddress: AccountAddressInput;
-  moduleName: string;
-  options?: LedgerVersionArg;
-}): Promise<MoveModuleBytecode> {
-  const { aptosConfig, accountAddress, moduleName, options } = args;
-
-  const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({
-    aptosConfig,
-    originMethod: "getModule",
-    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
-    params: { ledger_version: options?.ledgerVersion },
-  });
-  return data;
+  return getModuleUtil(args);
 }
 
 /**
@@ -815,3 +766,194 @@ export async function isAccountExist(args: { aptosConfig: AptosConfig; authKey:
     throw new Error(`Error while looking for an account info ${accountAddress.toString()}`);
   }
 }
+
+const rotateAuthKeyAbi: EntryFunctionABI = {
+  typeParameters: [],
+  parameters: [
+    new TypeTagU8(),
+    TypeTagVector.u8(),
+    new TypeTagU8(),
+    TypeTagVector.u8(),
+    TypeTagVector.u8(),
+    TypeTagVector.u8(),
+  ],
+};
+
+/**
+ * Rotates the authentication key for a given account.
+ *
+ * @param args - The arguments for rotating the authentication key.
+ * @param args.aptosConfig - The configuration settings for the Aptos network.
+ * @param args.fromAccount - The account from which the authentication key will be rotated.
+ * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey or toAuthKey.
+ * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount or toAuthKey.
+ * @param args.toAuthKey - (Optional) The new authentication key to rotate to. Can only be used with dangerouslySkipVerification=true.
+ * @param args.dangerouslySkipVerification - (Optional) If true, skips verification steps after rotation. Required when using toAuthKey.
+ *
+ * @remarks
+ * This function supports three modes of rotation:
+ * 1. Using a target Account object (toAccount)
+ * 2. Using a new private key (toNewPrivateKey)
+ * 3. Using a raw authentication key (toAuthKey) - requires dangerouslySkipVerification=true
+ *
+ * When not using dangerouslySkipVerification, the function performs additional safety checks and account setup.
+ *
+ * If the new key is a multi key, skipping verification is dangerous because verification will publish the public key onchain and
+ * prevent users from being locked out of the account from loss of knowledge of one of the public keys.
+ *
+ * @returns A promise that resolves to the pending transaction response.
+ * @throws Error if the rotation fails or verification fails.
+ *
+ * @group Implementation
+ */
+export async function rotateAuthKey(
+  args: {
+    aptosConfig: AptosConfig;
+    fromAccount: Account;
+  } & (
+    | { toAccount: Account; dangerouslySkipVerification?: never }
+    | { toNewPrivateKey: Ed25519PrivateKey; dangerouslySkipVerification?: never }
+    | { toAuthKey: AuthenticationKey; dangerouslySkipVerification: true }
+  ),
+): Promise<PendingTransactionResponse> {
+  const { aptosConfig, fromAccount, dangerouslySkipVerification } = args;
+  if ("toNewPrivateKey" in args) {
+    return rotateAuthKeyWithChallenge({
+      aptosConfig,
+      fromAccount,
+      toNewPrivateKey: args.toNewPrivateKey,
+    });
+  }
+  let authKey: AuthenticationKey;
+  if ("toAccount" in args) {
+    if (args.toAccount instanceof Ed25519Account) {
+      return rotateAuthKeyWithChallenge({ aptosConfig, fromAccount, toNewPrivateKey: args.toAccount.privateKey });
+    }
+    if (args.toAccount instanceof MultiEd25519Account) {
+      return rotateAuthKeyWithChallenge({ aptosConfig, fromAccount, toAccount: args.toAccount });
+    }
+    authKey = args.toAccount.publicKey.authKey();
+  } else if ("toAuthKey" in args) {
+    authKey = args.toAuthKey;
+  } else {
+    throw new Error("Invalid arguments");
+  }
+
+  const pendingTxn = await rotateAuthKeyUnverified({
+    aptosConfig,
+    fromAccount,
+    toAuthKey: authKey,
+  });
+
+  if (dangerouslySkipVerification === true) {
+    return pendingTxn;
+  }
+
+  const rotateAuthKeyTxnResponse = await waitForTransaction({
+    aptosConfig,
+    transactionHash: pendingTxn.hash,
+  });
+  if (!rotateAuthKeyTxnResponse.success) {
+    throw new Error(`Failed to rotate authentication key - ${rotateAuthKeyTxnResponse}`);
+  }
+
+  // Verify the rotation by setting the originating address to the new account.
+  // This verifies the rotation even if the transaction payload fails to execute successfully.
+  const verificationTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::set_originating_address",
+      functionArguments: [],
+    },
+  });
+
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: args.toAccount, // Use the new account to sign
+    transaction: verificationTxn,
+  });
+}
+
+async function rotateAuthKeyWithChallenge(
+  args: {
+    aptosConfig: AptosConfig;
+    fromAccount: Account;
+  } & ({ toNewPrivateKey: Ed25519PrivateKey } | { toAccount: MultiEd25519Account }),
+): Promise<PendingTransactionResponse> {
+  const { aptosConfig, fromAccount } = args;
+  const accountInfo = await getInfo({
+    aptosConfig,
+    accountAddress: fromAccount.accountAddress,
+  });
+
+  let newAccount: Account;
+  if ("toNewPrivateKey" in args) {
+    newAccount = Account.fromPrivateKey({ privateKey: args.toNewPrivateKey, legacy: true });
+  } else {
+    newAccount = args.toAccount;
+  }
+
+  const challenge = new RotationProofChallenge({
+    sequenceNumber: BigInt(accountInfo.sequence_number),
+    originator: fromAccount.accountAddress,
+    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),
+    newPublicKey: newAccount.publicKey,
+  });
+
+  // Sign the challenge
+  const challengeHex = challenge.bcsToBytes();
+  const proofSignedByCurrentKey = fromAccount.sign(challengeHex);
+  const proofSignedByNewKey = newAccount.sign(challengeHex);
+
+  // Generate transaction
+  const rawTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::rotate_authentication_key",
+      functionArguments: [
+        new U8(fromAccount.signingScheme), // from scheme
+        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
+        new U8(newAccount.signingScheme), // to scheme
+        MoveVector.U8(newAccount.publicKey.toUint8Array()),
+        MoveVector.U8(proofSignedByCurrentKey.toUint8Array()),
+        MoveVector.U8(proofSignedByNewKey.toUint8Array()),
+      ],
+      abi: rotateAuthKeyAbi,
+    },
+  });
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn,
+  });
+}
+
+const rotateAuthKeyUnverifiedAbi: EntryFunctionABI = {
+  typeParameters: [],
+  parameters: [TypeTagVector.u8()],
+};
+
+async function rotateAuthKeyUnverified(args: {
+  aptosConfig: AptosConfig;
+  fromAccount: Account;
+  toAuthKey: AuthenticationKey;
+}): Promise<PendingTransactionResponse> {
+  const { aptosConfig, fromAccount, toAuthKey } = args;
+  const authKey = toAuthKey;
+  const rawTxn = await generateTransaction({
+    aptosConfig,
+    sender: fromAccount.accountAddress,
+    data: {
+      function: "0x1::account::rotate_authentication_key_call",
+      functionArguments: [MoveVector.U8(authKey.toUint8Array())],
+      abi: rotateAuthKeyUnverifiedAbi,
+    },
+  });
+  return signAndSubmitTransaction({
+    aptosConfig,
+    signer: fromAccount,
+    transaction: rawTxn,
+  });
+}

package/src/internal/transactionSubmission.ts

@@ -7,13 +7,12 @@
  */
 
 import { AptosConfig } from "../api/aptosConfig";
-import { Deserializer, MoveVector, U8 } from "../bcs";
+import { Deserializer, MoveVector } from "../bcs";
 import { postAptosFullNode } from "../client";
 import { Account, AbstractKeylessAccount, isKeylessSigner } from "../account";
 import { AccountAddress, AccountAddressInput } from "../core/accountAddress";
-import { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature, PrivateKeyInput } from "../core/crypto";
+import { FederatedKeylessPublicKey, KeylessPublicKey, KeylessSignature } from "../core/crypto";
 import { AccountAuthenticator } from "../transactions/authenticator/account";
-import { RotationProofChallenge } from "../transactions/instances/rotationProofChallenge";
 import {
   buildTransaction,
   generateTransactionPayload,
@@ -32,9 +31,8 @@ import {
   AnyTransactionPayloadInstance,
   EntryFunctionABI,
 } from "../transactions/types";
-import { getInfo } from "./account";
-import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput, TransactionResponse } from "../types";
-import { SignedTransaction, TypeTagU8, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
+import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput } from "../types";
+import { SignedTransaction, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 import { MultiAgentTransaction } from "../transactions/instances/multiAgentTransaction";
 
@@ -444,78 +442,3 @@ export async function publicPackageTransaction(args: {
     options,
   });
 }
-
-const rotateAuthKeyAbi: EntryFunctionABI = {
-  typeParameters: [],
-  parameters: [
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    new TypeTagU8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8(),
-    TypeTagVector.u8(),
-  ],
-};
-
-/**
- * Rotates the authentication key for a given account, allowing for enhanced security and management of account access.
- *
- * @param args - The arguments for rotating the authentication key.
- * @param args.aptosConfig - The configuration settings for the Aptos network.
- * @param args.fromAccount - The account from which the authentication key will be rotated.
- * @param args.toNewPrivateKey - The new private key that will be associated with the account.
- *
- * @remarks
- * This function requires the current authentication key and the new private key to sign a challenge that validates the rotation.
- *
- * TODO: Need to refactor and move this function out of transactionSubmission.
- * @group Implementation
- */
-export async function rotateAuthKey(args: {
-  aptosConfig: AptosConfig;
-  fromAccount: Account;
-  toNewPrivateKey: PrivateKeyInput;
-}): Promise<TransactionResponse> {
-  const { aptosConfig, fromAccount, toNewPrivateKey } = args;
-  const accountInfo = await getInfo({
-    aptosConfig,
-    accountAddress: fromAccount.accountAddress,
-  });
-
-  const newAccount = Account.fromPrivateKey({ privateKey: toNewPrivateKey, legacy: true });
-
-  const challenge = new RotationProofChallenge({
-    sequenceNumber: BigInt(accountInfo.sequence_number),
-    originator: fromAccount.accountAddress,
-    currentAuthKey: AccountAddress.from(accountInfo.authentication_key),
-    newPublicKey: newAccount.publicKey,
-  });
-
-  // Sign the challenge
-  const challengeHex = challenge.bcsToBytes();
-  const proofSignedByCurrentPrivateKey = fromAccount.sign(challengeHex);
-  const proofSignedByNewPrivateKey = newAccount.sign(challengeHex);
-
-  // Generate transaction
-  const rawTxn = await generateTransaction({
-    aptosConfig,
-    sender: fromAccount.accountAddress,
-    data: {
-      function: "0x1::account::rotate_authentication_key",
-      functionArguments: [
-        new U8(fromAccount.signingScheme), // from scheme
-        MoveVector.U8(fromAccount.publicKey.toUint8Array()),
-        new U8(newAccount.signingScheme), // to scheme
-        MoveVector.U8(newAccount.publicKey.toUint8Array()),
-        MoveVector.U8(proofSignedByCurrentPrivateKey.toUint8Array()),
-        MoveVector.U8(proofSignedByNewPrivateKey.toUint8Array()),
-      ],
-      abi: rotateAuthKeyAbi,
-    },
-  });
-  return signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn,
-  });
-}

package/src/internal/utils/index.ts

@@ -0,0 +1,4 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./utils";

package/src/internal/utils/utils.ts

@@ -0,0 +1,116 @@
+import { AccountAddress, AccountAddressInput } from "../../core/accountAddress";
+import { MoveModuleBytecode, LedgerVersionArg, PaginationArgs, AccountData } from "../../types/types";
+import { AptosConfig } from "../../api/aptosConfig";
+import { getAptosFullNode, paginateWithObfuscatedCursor } from "../../client";
+import { memoizeAsync } from "../../utils/memoize";
+
+/**
+ * Retrieves the modules associated with a specified account address.
+ *
+ * @param args - The arguments for retrieving modules.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos blockchain.
+ * @param args.accountAddress - The address of the account whose modules are to be retrieved.
+ * @param args.options - Optional parameters for pagination and ledger version.
+ * @param args.options.limit - The maximum number of modules to retrieve (default is 1000).
+ * @param args.options.offset - The starting point for pagination.  Note, this is obfuscated and is not an index.
+ * @param args.options.ledgerVersion - The specific ledger version to query.
+ * @group Implementation
+ */
+export async function getModules(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  options?: PaginationArgs & LedgerVersionArg;
+}): Promise<MoveModuleBytecode[]> {
+  const { aptosConfig, accountAddress, options } = args;
+  return paginateWithObfuscatedCursor<{}, MoveModuleBytecode[]>({
+    aptosConfig,
+    originMethod: "getModules",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/modules`,
+    params: {
+      ledger_version: options?.ledgerVersion,
+      offset: options?.offset,
+      limit: options?.limit ?? 1000,
+    },
+  });
+}
+
+/**
+ * Retrieves account information for a specified account address.
+ *
+ * @param args - The arguments for retrieving account information.
+ * @param args.aptosConfig - The configuration object for Aptos.
+ * @param args.accountAddress - The address of the account to retrieve information for.
+ * @group Implementation
+ */
+export async function getInfo(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+}): Promise<AccountData> {
+  const { aptosConfig, accountAddress } = args;
+  const { data } = await getAptosFullNode<{}, AccountData>({
+    aptosConfig,
+    originMethod: "getInfo",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}`,
+  });
+  return data;
+}
+
+/**
+ * Queries for a move module given an account address and module name.
+ * This function can help you retrieve the module's ABI and other relevant information.
+ *
+ * @param args - The arguments for retrieving the module.
+ * @param args.aptosConfig - The configuration for the Aptos client.
+ * @param args.accountAddress - The account address in hex-encoded 32 byte format.
+ * @param args.moduleName - The name of the module to retrieve.
+ * @param args.options - Optional parameters for the request.
+ * @param args.options.ledgerVersion - Specifies the ledger version of transactions. By default, the latest version will be used.
+ * @returns The move module.
+ * @group Implementation
+ */
+export async function getModule(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  moduleName: string;
+  options?: LedgerVersionArg;
+}): Promise<MoveModuleBytecode> {
+  // We don't memoize the account module by ledger version, as it's not a common use case, this would be handled
+  // by the developer directly
+  if (args.options?.ledgerVersion !== undefined) {
+    return getModuleInner(args);
+  }
+
+  return memoizeAsync(
+    async () => getModuleInner(args),
+    `module-${args.accountAddress}-${args.moduleName}`,
+    1000 * 60 * 5, // 5 minutes
+  )();
+}
+
+/**
+ * Retrieves the bytecode of a specified module from a given account address.
+ *
+ * @param args - The parameters for retrieving the module bytecode.
+ * @param args.aptosConfig - The configuration for connecting to the Aptos network.
+ * @param args.accountAddress - The address of the account from which to retrieve the module.
+ * @param args.moduleName - The name of the module to retrieve.
+ * @param args.options - Optional parameters for specifying the ledger version.
+ * @param args.options.ledgerVersion - The specific ledger version to query.
+ * @group Implementation
+ */
+async function getModuleInner(args: {
+  aptosConfig: AptosConfig;
+  accountAddress: AccountAddressInput;
+  moduleName: string;
+  options?: LedgerVersionArg;
+}): Promise<MoveModuleBytecode> {
+  const { aptosConfig, accountAddress, moduleName, options } = args;
+
+  const { data } = await getAptosFullNode<{}, MoveModuleBytecode>({
+    aptosConfig,
+    originMethod: "getModule",
+    path: `accounts/${AccountAddress.from(accountAddress).toString()}/module/${moduleName}`,
+    params: { ledger_version: options?.ledgerVersion },
+  });
+  return data;
+}

package/src/transactions/scriptComposer/index.ts

@@ -5,9 +5,9 @@ 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 { standardizeTypeTags } from "../transactionBuilder";
 import { CallArgument } from "../../types";
-import { convertCallArgument } from "../transactionBuilder/remoteAbi";
+import { convertArgument, fetchModuleAbi } from "../transactionBuilder/remoteAbi";
 
 /**
  * A wrapper class around TransactionComposer, which is a WASM library compiled
@@ -58,19 +58,34 @@ export class AptosScriptComposer {
 
     // 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())));
+      for (const typeArgument of input.typeArguments) {
+        await this.builder.load_type_tag(nodeUrl, typeArgument.toString());
+      }
     }
     const typeArguments = standardizeTypeTags(input.typeArguments);
-    const functionAbi = await fetchMoveFunctionAbi(moduleAddress, moduleName, functionName, this.config);
+    const moduleAbi = await fetchModuleAbi(moduleAddress, moduleName, this.config);
+    if (!moduleAbi) {
+      throw new Error(`Could not find module ABI for '${moduleAddress}::${moduleName}'`);
+    }
+
     // Check the type argument count against the ABI
-    if (typeArguments.length !== functionAbi.typeParameters.length) {
+    const functionAbi = moduleAbi?.exposed_functions.find((func) => func.name === functionName);
+    if (!functionAbi) {
+      throw new Error(`Could not find function ABI for '${moduleAddress}::${moduleName}::${functionName}'`);
+    }
+
+    if (typeArguments.length !== functionAbi.generic_type_params.length) {
       throw new Error(
-        `Type argument count mismatch, expected ${functionAbi.typeParameters.length}, received ${typeArguments.length}`,
+        `Type argument count mismatch, expected ${functionAbi?.generic_type_params.length}, received ${typeArguments.length}`,
       );
     }
 
     const functionArguments: CallArgument[] = input.functionArguments.map((arg, i) =>
-      convertCallArgument(arg, functionName, functionAbi, i, typeArguments),
+      arg instanceof CallArgument
+        ? arg
+        : CallArgument.newBytes(
+            convertArgument(functionName, moduleAbi, arg, i, typeArguments, { allowUnknownStructs: true }).bcsToBytes(),
+          ),
     );
 
     return this.builder.add_batched_call(