@aptos-labs/ts-sdk 3.1.2 → 4.0.0-zeta.0

package/src/api/transaction.ts

@@ -36,14 +36,14 @@ import {
   InputGenerateTransactionPayloadData,
   InputTransactionPluginData,
 } from "../transactions";
-import { AccountAddressInput, AuthenticationKey, Ed25519PrivateKey } from "../core";
-import { Account } from "../account";
+import { AccountAddressInput, AccountPublicKey, AuthenticationKey, Ed25519PrivateKey } from "../core";
+import { Account, Ed25519Account, MultiEd25519Account } from "../account";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
 import { TransactionManagement } from "./transactionSubmission/management";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
-import { rotateAuthKey } from "../internal/account";
+import { rotateAuthKey, rotateAuthKeyUnverified } from "../internal/account";
 
 /**
  * Represents a transaction in the Aptos blockchain,
@@ -480,43 +480,33 @@ export class Transaction {
    *
    * @param args - The arguments for rotating the authentication key.
    * @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.
+   * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey.
+   * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount.
    *
    * @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.
+   * For Ed25519 accounts, the function will use a challenge-based rotation that requires signatures from both the old and new keys.
+   * For multi-key accounts like MultiEd25519Account, the function will use a challenge-based rotation that requires signatures from both keys.
+   * For other account types, the function will use an unverified rotation that only requires the new public key.
    *
-   * 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 PendingTransactionResponse
+   * @returns SimpleTransaction that can be submitted to rotate the auth key
    *
    * @example
    * ```typescript
-   * import { Aptos, AptosConfig, Network, Account, PrivateKey } from "@aptos-labs/ts-sdk";
-   *
-   * const config = new AptosConfig({ network: Network.TESTNET });
-   * const aptos = new Aptos(config);
-   *
-   * async function runExample() {
-   *   // Rotate the authentication key for an account
-   *   const response = await aptos.rotateAuthKey({
-   *     // replace with a real account
-   *     fromAccount: Account.generate(),
-   *     // replace with a real private key
-   *     toNewPrivateKey: new PrivateKey("0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"),
-   *   });
-   *
-   *   console.log(response);
-   * }
-   * runExample().catch(console.error);
+   * // Create and submit transaction to rotate the auth key
+   * const transaction = await aptos.rotateAuthKey({
+   *   fromAccount,
+   *   toAccount: toAccount,
+   * });
+   *
+   * // Sign and submit the transaction
+   * const pendingTransaction = await aptos.signAndSubmitTransaction({
+   *   signer: fromAccount,
+   *   transaction,
+   * });
    * ```
    * @group Transaction
    */
@@ -524,15 +514,48 @@ export class Transaction {
     args: {
       fromAccount: Account;
       options?: InputGenerateTransactionOptions;
-    } & (
-      | { toAccount: Account; dangerouslySkipVerification?: never }
-      | { toNewPrivateKey: Ed25519PrivateKey; dangerouslySkipVerification?: never }
-      | { toAuthKey: AuthenticationKey; dangerouslySkipVerification: true }
-    ),
-  ): Promise<PendingTransactionResponse> {
+    } & ({ toAccount: Ed25519Account | MultiEd25519Account } | { toNewPrivateKey: Ed25519PrivateKey }),
+  ): Promise<SimpleTransaction> {
     return rotateAuthKey({ aptosConfig: this.config, ...args });
   }
 
+  /**
+   * Rotates the authentication key for a given account without verifying the new key.
+   *
+   * Accounts with their auth key rotated via this function will be derivable via the `getAccountsForPublicKey` and
+   * `deriveOwnedAccountsFromSigner` functions however the public key will be unverified (no proof of ownership). Thus
+   * includeUnverified must be set to true to derive the account until the public key is verified via signing a transaction.
+   *
+   * @param args - The arguments for rotating the authentication key.
+   * @param args.fromAccount - The account from which the authentication key will be rotated.
+   * @param args.toNewPublicKey - The new public key to rotate to.
+   *
+   * @returns A simple transaction object that can be submitted to the network.
+   *
+   * @example
+   * ```typescript
+   * // Create and submit transaction to rotate the auth key
+   * const transaction = await aptos.rotateAuthKeyUnverified({
+   *   fromAccount,
+   *   toNewPublicKey,
+   * });
+   *
+   * // Sign and submit the transaction
+   * const pendingTransaction = await aptos.signAndSubmitTransaction({
+   *   signer: fromAccount,
+   *   transaction,
+   * });
+   * ```
+   * @group Transaction
+   */
+  async rotateAuthKeyUnverified(args: {
+    fromAccount: Account;
+    options?: InputGenerateTransactionOptions;
+    toNewPublicKey: AccountPublicKey;
+  }): Promise<SimpleTransaction> {
+    return rotateAuthKeyUnverified({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Sign a transaction that can later be submitted to the chain.
    * This function is essential for ensuring the authenticity of the transaction by using the provided account's signing capabilities.

package/src/core/crypto/utils.ts

@@ -1,5 +1,13 @@
-import { HexInput } from "../../types";
+import { HexInput, SigningScheme } from "../../types";
 import { Hex } from "../hex";
+import { Ed25519PublicKey } from "./ed25519";
+import { FederatedKeylessPublicKey } from "./federatedKeyless";
+import { KeylessPublicKey } from "./keyless";
+import { MultiEd25519PublicKey } from "./multiEd25519";
+import { MultiKey } from "./multiKey";
+import { AccountPublicKey } from "./publicKey";
+import { AnyPublicKey } from "./singleKey";
+import { BaseAccountPublicKey } from "./types";
 
 /**
  * Helper function to convert a message to sign or to verify to a valid message input
@@ -24,3 +32,32 @@ export const convertSigningMessage = (message: HexInput): HexInput => {
   // message is a Uint8Array
   return message;
 };
+
+export const accountPublicKeyToBaseAccountPublicKey = (publicKey: AccountPublicKey): BaseAccountPublicKey => {
+  if (
+    publicKey instanceof Ed25519PublicKey ||
+    publicKey instanceof AnyPublicKey ||
+    publicKey instanceof MultiEd25519PublicKey ||
+    publicKey instanceof MultiKey
+  ) {
+    return publicKey;
+  }
+  if (publicKey instanceof KeylessPublicKey || publicKey instanceof FederatedKeylessPublicKey) {
+    return new AnyPublicKey(publicKey);
+  }
+  throw new Error(`Unknown account public key: ${publicKey}`);
+};
+
+export const accountPublicKeyToSigningScheme = (publicKey: AccountPublicKey): SigningScheme => {
+  const baseAccountPublicKey = accountPublicKeyToBaseAccountPublicKey(publicKey);
+  if (baseAccountPublicKey instanceof Ed25519PublicKey) {
+    return SigningScheme.Ed25519;
+  } else if (baseAccountPublicKey instanceof AnyPublicKey) {
+    return SigningScheme.SingleKey;
+  } else if (baseAccountPublicKey instanceof MultiEd25519PublicKey) {
+    return SigningScheme.MultiEd25519;
+  } else if (baseAccountPublicKey instanceof MultiKey) {
+    return SigningScheme.MultiKey;
+  }
+  throw new Error(`Unknown signing scheme: ${baseAccountPublicKey}`);
+};

package/src/internal/account.ts

@@ -93,6 +93,7 @@ import {
   EntryFunctionABI,
   InputGenerateTransactionOptions,
   RotationProofChallenge,
+  SimpleTransaction,
   TypeTagU8,
   TypeTagVector,
 } from "../transactions";
@@ -100,6 +101,7 @@ import { U8, MoveVector } from "../bcs";
 import { waitForTransaction, waitForIndexer } from "./transaction";
 import { view } from "./view";
 import { getLedgerInfo } from "./general";
+import { accountPublicKeyToBaseAccountPublicKey, accountPublicKeyToSigningScheme } from "../core/crypto/utils";
 
 /**
  * Retrieves account information for a specified account address.
@@ -933,23 +935,15 @@ const rotateAuthKeyAbi: EntryFunctionABI = {
  * @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.
+ * @param args.toAccount - (Optional) The target account to rotate to. Required if not using toNewPrivateKey.
+ * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount.
  *
  * @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.
+ * @returns A simple transaction object that can be submitted to the network.
  * @throws Error if the rotation fails or verification fails.
  *
  * @group Implementation
@@ -959,13 +953,9 @@ export async function rotateAuthKey(
     aptosConfig: AptosConfig;
     fromAccount: Account;
     options?: InputGenerateTransactionOptions;
-  } & (
-    | { toAccount: Account; dangerouslySkipVerification?: never }
-    | { toNewPrivateKey: Ed25519PrivateKey; dangerouslySkipVerification?: never }
-    | { toAuthKey: AuthenticationKey; dangerouslySkipVerification: true }
-  ),
-): Promise<PendingTransactionResponse> {
-  const { aptosConfig, fromAccount, dangerouslySkipVerification, options } = args;
+  } & ({ toAccount: Ed25519Account | MultiEd25519Account } | { toNewPrivateKey: Ed25519PrivateKey }),
+): Promise<SimpleTransaction> {
+  const { aptosConfig, fromAccount, options } = args;
   if ("toNewPrivateKey" in args) {
     return rotateAuthKeyWithChallenge({
       aptosConfig,
@@ -973,9 +963,7 @@ export async function rotateAuthKey(
       toNewPrivateKey: args.toNewPrivateKey,
       options,
     });
-  }
-  let authKey: AuthenticationKey;
-  if ("toAccount" in args) {
+  } else if ("toAccount" in args) {
     if (args.toAccount instanceof Ed25519Account) {
       return rotateAuthKeyWithChallenge({
         aptosConfig,
@@ -983,52 +971,12 @@ export async function rotateAuthKey(
         toNewPrivateKey: args.toAccount.privateKey,
         options,
       });
-    }
-    if (args.toAccount instanceof MultiEd25519Account) {
+    } else {
       return rotateAuthKeyWithChallenge({ aptosConfig, fromAccount, toAccount: args.toAccount, options });
     }
-    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,
-    options,
-  });
-
-  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(
@@ -1037,7 +985,7 @@ async function rotateAuthKeyWithChallenge(
     fromAccount: Account;
     options?: InputGenerateTransactionOptions;
   } & ({ toNewPrivateKey: Ed25519PrivateKey } | { toAccount: MultiEd25519Account }),
-): Promise<PendingTransactionResponse> {
+): Promise<SimpleTransaction> {
   const { aptosConfig, fromAccount, options } = args;
   const accountInfo = await getInfo({
     aptosConfig,
@@ -1064,7 +1012,7 @@ async function rotateAuthKeyWithChallenge(
   const proofSignedByNewKey = newAccount.sign(challengeHex);
 
   // Generate transaction
-  const rawTxn = await generateTransaction({
+  return generateTransaction({
     aptosConfig,
     sender: fromAccount.accountAddress,
     data: {
@@ -1081,41 +1029,46 @@ async function rotateAuthKeyWithChallenge(
     },
     options,
   });
-  return signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn,
-  });
 }
 
 const rotateAuthKeyUnverifiedAbi: EntryFunctionABI = {
   typeParameters: [],
-  parameters: [TypeTagVector.u8()],
+  parameters: [new TypeTagU8(), TypeTagVector.u8()],
 };
 
-async function rotateAuthKeyUnverified(args: {
+/**
+ * Rotates the authentication key for a given account without verifying the new key.
+ *
+ * @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.toNewPublicKey - The new public key to rotate to.
+ * @returns A simple transaction object that can be submitted to the network.
+ * @throws Error if the rotation fails or verification fails.
+ *
+ * @group Implementation
+ */
+export async function rotateAuthKeyUnverified(args: {
   aptosConfig: AptosConfig;
   fromAccount: Account;
-  toAuthKey: AuthenticationKey;
+  toNewPublicKey: AccountPublicKey;
   options?: InputGenerateTransactionOptions;
-}): Promise<PendingTransactionResponse> {
-  const { aptosConfig, fromAccount, toAuthKey, options } = args;
-  const authKey = toAuthKey;
-  const rawTxn = await generateTransaction({
+}): Promise<SimpleTransaction> {
+  const { aptosConfig, fromAccount, toNewPublicKey, options } = args;
+
+  return generateTransaction({
     aptosConfig,
     sender: fromAccount.accountAddress,
     data: {
-      function: "0x1::account::rotate_authentication_key_call",
-      functionArguments: [MoveVector.U8(authKey.toUint8Array())],
+      function: "0x1::account::rotate_authentication_key_from_public_key",
+      functionArguments: [
+        new U8(accountPublicKeyToSigningScheme(toNewPublicKey)), // to scheme
+        MoveVector.U8(accountPublicKeyToBaseAccountPublicKey(toNewPublicKey).toUint8Array()),
+      ],
       abi: rotateAuthKeyUnverifiedAbi,
     },
     options,
   });
-  return signAndSubmitTransaction({
-    aptosConfig,
-    signer: fromAccount,
-    transaction: rawTxn,
-  });
 }
 
 export type AccountInfo = {

package/src/internal/ans.ts

@@ -184,6 +184,9 @@ export async function getOwnerAddress(args: {
  * @param sender - The account initiating the name registration.
  * @param name - The name to be registered.
  * @param expiration - The expiration policy for the name registration.
+ * @param transferable - Whether the name can be transferred to another owner.
+ * @param toAddress - The address that will be set as the owner_address of the name.
+ * @param targetAddress - The address that this name will resolve to.
  * @group Implementation
  */
 export interface RegisterNameParameters {
@@ -209,10 +212,10 @@ export interface RegisterNameParameters {
  * @param args.expiration - The expiration details for the registration.
  * @param args.name - The name to be registered, which can be a domain or subdomain.
  * @param args.sender - The account details of the sender initiating the registration.
- * @param args.targetAddress - The target address for the registration.
- * @param args.toAddress - The address to which the registration is associated.
+ * @param args.targetAddress - The target address for the registration, which is the address the name will resolve to.
+ * @param args.toAddress - The address that will be set as the owner_address in records, defaults to sender if not provided.
  * @param args.options - Additional options for the registration process.
- * @param args.transferable - Indicates whether the registered name is transferable.
+ * @param args.transferable - Indicates whether the registered name is transferable to another account.
  *
  * @throws Error if the provided expiration policy is invalid for subdomains.
  * @throws Error if the domain does not exist.
@@ -414,6 +417,8 @@ export async function setPrimaryName(args: {
 
 /**
  * Retrieves the target address associated with a given domain name and subdomain name.
+ * The target address is different from the owner address - it's the address this name
+ * resolves to, which may be different from who owns the name.
  *
  * @param args - The arguments for retrieving the target address.
  * @param args.aptosConfig - The Aptos configuration object.
@@ -542,7 +547,8 @@ export interface GetAccountNamesArgs extends QueryNamesOptions {
 }
 
 /**
- * Retrieves the current Aptos names associated with a specific account address.
+ * Retrieves all the current Aptos names owned by an account. This uses the
+ * owner_address field, not the registered_address field.
  *
  * @param args - The arguments for retrieving account names.
  * @param args.aptosConfig - The configuration object for Aptos.
@@ -595,7 +601,8 @@ export interface GetAccountDomainsArgs extends QueryNamesOptions {
 }
 
 /**
- * Retrieves the list of top-level domains owned by a specified account.
+ * Retrieves the list of top-level domains owned by a specified account,
+ * using the owner_address field.
  *
  * @param args - The arguments for retrieving account domains.
  * @param args.aptosConfig - The Aptos configuration object.
@@ -651,8 +658,8 @@ export interface GetAccountSubdomainsArgs extends QueryNamesOptions {
 }
 
 /**
- * Retrieves a list of subdomains owned by a specified account address.
- * This function helps you identify all subdomains associated with a given account.
+ * Retrieves a list of subdomains owned by a specified account address, determined
+ * by the owner_address field.
  *
  * @param args - The arguments for retrieving account subdomains.
  * @param args.aptosConfig - The configuration object for Aptos.
@@ -707,7 +714,11 @@ export interface GetDomainSubdomainsArgs extends QueryNamesOptions {
 }
 
 /**
- * Retrieve the active subdomains associated with a specified domain.
+ * Retrieve the active subdomains associated with a specified domain,
+ * regardless of who is in possession of the domain.
+ *
+ * This function queries by domain name only, not by owner, so it will return
+ * all subdomains of a domain even if they're owned by different accounts.
  *
  * @param args - The arguments for retrieving subdomains.
  * @param args.aptosConfig - The configuration settings for Aptos.

package/src/internal/move/jwks/build/jwk/BuildInfo.yaml

@@ -0,0 +1,56 @@
+---
+compiled_package_info:
+  package_name: jwk
+  address_alias_instantiation:
+    Extensions: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_framework: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_fungible_asset: 000000000000000000000000000000000000000000000000000000000000000a
+    aptos_std: "0000000000000000000000000000000000000000000000000000000000000001"
+    aptos_token: "0000000000000000000000000000000000000000000000000000000000000003"
+    core_resources: 000000000000000000000000000000000000000000000000000000000a550c18
+    std: "0000000000000000000000000000000000000000000000000000000000000001"
+    vm: "0000000000000000000000000000000000000000000000000000000000000000"
+    vm_reserved: "0000000000000000000000000000000000000000000000000000000000000000"
+  source_digest: 3437D4FB002907781F0FE5D46FC4E668C8B8F0420AA77751774AD63B0C2730BF
+  build_flags:
+    dev_mode: false
+    test_mode: false
+    override_std: ~
+    generate_docs: false
+    generate_abis: false
+    generate_move_model: true
+    full_model_generation: false
+    install_dir: ~
+    force_recompilation: false
+    additional_named_addresses: {}
+    architecture: ~
+    fetch_deps_only: false
+    skip_fetch_latest_git_deps: false
+    compiler_config:
+      bytecode_version: 6
+      known_attributes:
+        - bytecode_instruction
+        - deprecated
+        - event
+        - expected_failure
+        - "fmt::skip"
+        - legacy_entry_fun
+        - "lint::allow_unsafe_randomness"
+        - "lint::skip"
+        - native_interface
+        - randomness
+        - resource_group
+        - resource_group_member
+        - test
+        - test_only
+        - verify_only
+        - view
+      skip_attribute_checks: false
+      compiler_version: ~
+      language_version: ~
+      experiments:
+        - optimize=on
+dependencies:
+  - AptosFramework
+  - AptosStdlib
+  - MoveStdlib