@aptos-labs/ts-sdk 1.35.0-zeta.0 → 1.35.0-zeta.2

package/src/internal/transactionSubmission.ts

@@ -7,19 +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 {
-  Ed25519PrivateKey,
-  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,
@@ -38,22 +31,10 @@ import {
   AnyTransactionPayloadInstance,
   EntryFunctionABI,
 } from "../transactions/types";
-import { getInfo } from "./account";
-import {
-  UserTransactionResponse,
-  PendingTransactionResponse,
-  MimeType,
-  HexInput,
-  TransactionResponse,
-  CommittedTransactionResponse,
-} 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";
-import { MultiEd25519Account } from "../account/MultiEd25519Account";
-import { AuthenticationKey, Hex } from "../core";
-import { waitForTransaction } from "./transaction";
-import { transferCoinTransaction } from "./coin";
 
 /**
  * We are defining function signatures, each with its specific input and output.
@@ -461,182 +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(),
-  ],
-};
-
-const rotateAuthKeyUnverifiedAbi: EntryFunctionABI = {
-  typeParameters: [],
-  parameters: [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: Ed25519PrivateKey;
-}): Promise<PendingTransactionResponse> {
-  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,
-  });
-}
-
-export async function rotateAuthKeyToMultiEd25519(args: {
-  aptosConfig: AptosConfig;
-  fromAccount: Account;
-  multiEd25519Account: MultiEd25519Account;
-}): Promise<PendingTransactionResponse> {
-  const { aptosConfig, fromAccount, multiEd25519Account } = args;
-  const accountInfo = await getInfo({
-    aptosConfig,
-    accountAddress: fromAccount.accountAddress,
-  });
-
-  const newAccount = multiEd25519Account;
-
-  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,
-  });
-}
-
-export async function rotateAuthKeyWithVerificationTransaction(args: {
-  aptosConfig: AptosConfig;
-  fromAccount: Account;
-  toAccount: Account;
-}): Promise<CommittedTransactionResponse> {
-  const { aptosConfig, fromAccount, toAccount } = args;
-
-  // Generate transaction
-  const rawTxn = await generateTransaction({
-    aptosConfig,
-    sender: fromAccount.accountAddress,
-    data: {
-      function: "0x1::account::rotate_authentication_key_call",
-      functionArguments: [MoveVector.U8(toAccount.publicKey.authKey().toUint8Array())],
-      abi: rotateAuthKeyUnverifiedAbi,
-    },
-  });
-  const pendingTxn = await signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn,
-  });
-  const txnResponse = await waitForTransaction({
-    aptosConfig,
-    transactionHash: pendingTxn.hash,
-  });
-  if (!txnResponse.success) {
-    throw new Error(`Failed to rotate authentication key - ${txnResponse}`);
-  }
-  const coinTxn = await transferCoinTransaction({
-    aptosConfig,
-    sender: toAccount.accountAddress,
-    recipient: toAccount.accountAddress,
-    amount: 1,
-  });
-  const pendingCoinTxn = await signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: coinTxn,
-  });
-  const coinTxnResponse = await waitForTransaction({
-    aptosConfig,
-    transactionHash: pendingCoinTxn.hash,
-  });
-  if (!coinTxnResponse.success) {
-    throw new Error(`Failed to verify authentication key - ${coinTxnResponse}`);
-  }
-  return coinTxnResponse;
-}

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

@@ -58,7 +58,9 @@ 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);

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -25,7 +25,7 @@ import {
 } from "../types";
 import { Bool, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
 import { AccountAddress } from "../../core";
-import { getModule } from "../../internal/account";
+import { getModule } from "../../internal/utils";
 import {
   findFirstNonSignerArg,
   isBcsAddress,

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -20,7 +20,7 @@ import {
   MultiKeySignature,
 } from "../../core/crypto";
 import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
-import { getInfo } from "../../internal/account";
+import { getInfo } from "../../internal/utils";
 import { getLedgerInfo } from "../../internal/general";
 import { getGasPriceEstimation } from "../../internal/transaction";
 import { NetworkToChainId } from "../../utils/apiEndpoints";
@@ -638,7 +638,12 @@ export function getAuthenticatorForSimulation(publicKey?: PublicKey) {
     return new AccountAuthenticatorMultiKey(
       accountPublicKey,
       new MultiKeySignature({
-        signatures: accountPublicKey.publicKeys.map(() => new AnySignature(invalidSignature)),
+        signatures: accountPublicKey.publicKeys.map((pubKey) => {
+          if (KeylessPublicKey.isInstance(pubKey.publicKey) || FederatedKeylessPublicKey.isInstance(pubKey.publicKey)) {
+            return new AnySignature(KeylessSignature.getSimulationSignature());
+          }
+          return new AnySignature(invalidSignature);
+        }),
         bitmap: accountPublicKey.createBitmap({
           bits: Array(accountPublicKey.publicKeys.length)
             .fill(0)

package/src/types/types.ts

@@ -1041,6 +1041,30 @@ export function isSingleSenderSignature(
   return signature.type === "single_sender";
 }
 
+/**
+ * Determine if the provided signature is of type "single_sender".
+ *
+ * @param signature - The transaction signature to check.
+ * @returns A boolean indicating whether the signature is a single-sender signature.
+ */
+export function isSingleSenderSingleKeySignature(
+  signature: TransactionSignature,
+): signature is TransactionSingleSenderSingleKeySignature {
+  return signature.type === "single_sender" && !("signatures_required" in signature);
+}
+
+/**
+ * Determine if the provided signature is of type "single_sender".
+ *
+ * @param signature - The transaction signature to check.
+ * @returns A boolean indicating whether the signature is a single-sender signature.
+ */
+export function isSingleSenderMultiKeySignature(
+  signature: TransactionSignature,
+): signature is TransactionSingleSenderMultiKeySignature {
+  return signature.type === "single_sender" && "signatures_required" in signature;
+}
+
 /**
  * The signature for a transaction using the Ed25519 algorithm.
  */
@@ -1062,10 +1086,23 @@ export type TransactionSecp256k1Signature = {
 /**
  * The structure for a multi-signature transaction using Ed25519.
  */
-export type TransactionSingleSenderSignature = {
+export type TransactionSingleSenderSignature = TransactionSingleSenderSingleKeySignature | TransactionSingleSenderMultiKeySignature;
+
+export type TransactionSingleSenderSingleKeySignature = {
   type: "single_sender";
   public_key: { value: string; type: string };
   signature: { value: string; type: string };
+  signatures_required: never;
+};
+
+/**
+ * The structure for a multi-signature transaction using Ed25519.
+ */
+export type TransactionSingleSenderMultiKeySignature = {
+  type: "single_sender";
+  public_keys: { value: string; type: string }[];
+  signatures: { index: number; signature: { value: string; type: string } }[];
+  signatures_required: number;
 };
 
 /**