@aptos-labs/ts-sdk 7.3.0 → 7.5.0

package/src/internal/account.ts

@@ -951,48 +951,41 @@ async function doesAccountExistAtAddress(args: {
 }): Promise<boolean> {
   const { aptosConfig, accountAddress, options } = args;
   try {
-    // Get the account resources and the balance of the account.  We need to check both because
-    // an account resource can exist with 0 balance and a balance can exist without an account resource (light accounts).
-    const [accountResource, ownedObjects] = await Promise.all([
-      getResourceFallible<{ authentication_key: string }>({
-        aptosConfig,
-        accountAddress,
-        resourceType: "0x1::account::Account",
-      }),
-      getAccountOwnedObjects({
-        aptosConfig,
-        accountAddress,
-        options: {
-          limit: 1,
-        },
-      }),
-    ]);
+    // Check the account resource first. For standard accounts this is sufficient proof of
+    // existence, and querying owned objects in parallel used to fail the whole check when
+    // the indexer `current_objects` query timed out.
+    const accountResource = await getResourceFallible<{ authentication_key: string }>({
+      aptosConfig,
+      accountAddress,
+      resourceType: "0x1::account::Account",
+    });
 
-    // If the account resource is not found and the balance is 0, then the account does not exist.
-    if (!accountResource && ownedObjects.length === 0) {
-      return false;
+    if (accountResource) {
+      if (!options?.withAuthKey) {
+        return true;
+      }
+      return accountResource.authentication_key === options.withAuthKey.toString();
     }
 
-    // If no auth key is provided as an argument, return true.
-    if (!options?.withAuthKey) {
-      return true;
-    }
+    // No account resource: still treat light accounts (objects but no resource) as existing.
+    const ownedObjects = await getAccountOwnedObjects({
+      aptosConfig,
+      accountAddress,
+      options: {
+        limit: 1,
+      },
+    });
 
-    // Get the auth key from the account resource if it exists. If the account resource does not exist,
-    // then the auth key is the account address by default.
-    let authKey;
-    if (accountResource) {
-      authKey = accountResource.authentication_key;
-    } else {
-      authKey = accountAddress.toStringLong();
+    if (ownedObjects.length === 0) {
+      return false;
     }
 
-    if (authKey !== options.withAuthKey.toString()) {
-      return false;
+    if (!options?.withAuthKey) {
+      return true;
     }
 
-    // Else the account exists and the auth key matches.
-    return true;
+    // Light accounts have no resource, so the auth key is the account address by convention.
+    return accountAddress.toStringLong() === options.withAuthKey.toString();
   } catch (error: any) {
     throw new Error(`Error while checking if account exists at ${accountAddress.toString()}: ${error}`);
   }
@@ -1028,6 +1021,8 @@ function rotateAuthKeyAbi(): EntryFunctionABI {
  * @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.
  * @param args.toNewPrivateKey - (Optional) The new private key to rotate to. Required if not using toAccount.
+ * @param args.withFeePayer - Whether to build a sponsored transaction.
+ * @param args.options - Optional settings for generating the transaction.
  *
  * @remarks
  * This function supports three modes of rotation:
@@ -1043,15 +1038,17 @@ export async function rotateAuthKey(
   args: {
     aptosConfig: AptosConfig;
     fromAccount: Account;
+    withFeePayer?: boolean;
     options?: InputGenerateTransactionOptions;
   } & ({ toAccount: Ed25519Account | MultiEd25519Account } | { toNewPrivateKey: Ed25519PrivateKey }),
 ): Promise<SimpleTransaction> {
-  const { aptosConfig, fromAccount, options } = args;
+  const { aptosConfig, fromAccount, withFeePayer, options } = args;
   if ("toNewPrivateKey" in args) {
     return rotateAuthKeyWithChallenge({
       aptosConfig,
       fromAccount,
       toNewPrivateKey: args.toNewPrivateKey,
+      withFeePayer,
       options,
     });
   }
@@ -1061,22 +1058,42 @@ export async function rotateAuthKey(
         aptosConfig,
         fromAccount,
         toNewPrivateKey: args.toAccount.privateKey,
+        withFeePayer,
         options,
       });
     }
-    return rotateAuthKeyWithChallenge({ aptosConfig, fromAccount, toAccount: args.toAccount, options });
+    return rotateAuthKeyWithChallenge({
+      aptosConfig,
+      fromAccount,
+      toAccount: args.toAccount,
+      withFeePayer,
+      options,
+    });
   }
   throw new Error("Invalid arguments");
 }
 
+/**
+ * Builds a challenge-based authentication-key rotation transaction.
+ *
+ * @param args - The arguments for the challenge-based rotation.
+ * @param args.aptosConfig - The configuration settings for the Aptos network.
+ * @param args.fromAccount - The account whose authentication key will be rotated.
+ * @param args.toAccount - The optional target multi-signature account.
+ * @param args.toNewPrivateKey - The optional target private key.
+ * @param args.withFeePayer - Whether to build a sponsored transaction.
+ * @param args.options - Optional settings for generating the transaction.
+ * @returns A transaction that rotates the authentication key.
+ */
 async function rotateAuthKeyWithChallenge(
   args: {
     aptosConfig: AptosConfig;
     fromAccount: Account;
+    withFeePayer?: boolean;
     options?: InputGenerateTransactionOptions;
   } & ({ toNewPrivateKey: Ed25519PrivateKey } | { toAccount: MultiEd25519Account }),
 ): Promise<SimpleTransaction> {
-  const { aptosConfig, fromAccount, options } = args;
+  const { aptosConfig, fromAccount, withFeePayer, options } = args;
   const accountInfo = await getInfo({
     aptosConfig,
     accountAddress: fromAccount.accountAddress,
@@ -1105,6 +1122,7 @@ async function rotateAuthKeyWithChallenge(
   return generateTransaction({
     aptosConfig,
     sender: fromAccount.accountAddress,
+    withFeePayer,
     data: {
       function: "0x1::account::rotate_authentication_key",
       functionArguments: [
@@ -1139,6 +1157,8 @@ function rotateAuthKeyUnverifiedAbi(): EntryFunctionABI {
  * @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.
+ * @param args.withFeePayer - Whether to build a sponsored transaction.
+ * @param args.options - Optional settings for generating the transaction.
  * @returns A simple transaction object that can be submitted to the network.
  * @throws Error if the rotation fails or verification fails.
  *
@@ -1148,13 +1168,15 @@ export async function rotateAuthKeyUnverified(args: {
   aptosConfig: AptosConfig;
   fromAccount: Account;
   toNewPublicKey: AccountPublicKey;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }): Promise<SimpleTransaction> {
-  const { aptosConfig, fromAccount, toNewPublicKey, options } = args;
+  const { aptosConfig, fromAccount, toNewPublicKey, withFeePayer, options } = args;
 
   return generateTransaction({
     aptosConfig,
     sender: fromAccount.accountAddress,
+    withFeePayer,
     data: {
       function: "0x1::account::rotate_authentication_key_from_public_key",
       functionArguments: [

package/src/internal/ans.ts

@@ -141,7 +141,7 @@ export const LOCAL_ANS_ACCOUNT_ADDRESS =
   getEnvVar("ANS_TEST_ACCOUNT_ADDRESS") ?? "0x585fc9f0f0c54183b039ffc770ca282ebd87307916c215a3e692f2f8e4305e82";
 
 const NetworkToAnsContract: Record<Network, string | null> = {
-  [Network.TESTNET]: "0x5f8fd2347449685cf41d4db97926ec3a096eaf381332be4f1318ad4d16a8497c",
+  [Network.TESTNET]: "0xb1ae61606dfbe0ea5b5c45ffdb4fb08da0dba18c5125182ff63ab280a450ecf4",
   [Network.MAINNET]: "0x867ed1f6bf916171b1de3ee92849b8978b7d1b9e0a8cc982a3d19d535dfd9c0c",
   [Network.LOCAL]: LOCAL_ANS_ACCOUNT_ADDRESS,
   [Network.CUSTOM]: null,
@@ -166,7 +166,7 @@ function getRouterAddress(aptosConfig: AptosConfig): string {
 }
 
 const unwrapOption = <T>(option: any): T | undefined => {
-  if (!!option && typeof option === "object" && "vec" in option && Array.isArray(option.vec)) {
+  if (option && typeof option === "object" && "vec" in option && Array.isArray(option.vec)) {
     return option.vec[0];
   }
 
@@ -213,6 +213,7 @@ export async function getOwnerAddress(args: {
  * @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.
+ * @param withFeePayer - Whether to build a fee-payer transaction.
  * @group Implementation
  */
 export interface RegisterNameParameters {
@@ -226,6 +227,7 @@ export interface RegisterNameParameters {
   transferable?: boolean;
   toAddress?: AccountAddressInput;
   targetAddress?: AccountAddressInput;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }
 
@@ -240,6 +242,7 @@ export interface RegisterNameParameters {
  * @param args.sender - The account details of the sender initiating the registration.
  * @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.withFeePayer - Whether to build a fee-payer transaction.
  * @param args.options - Additional options for the registration process.
  * @param args.transferable - Indicates whether the registered name is transferable to another account.
  *
@@ -253,7 +256,7 @@ export interface RegisterNameParameters {
 export async function registerName(
   args: RegisterNameParameters,
 ): Promise<{ transaction: SimpleTransaction; data: InputEntryFunctionData }> {
-  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options, transferable } = args;
+  const { aptosConfig, expiration, name, sender, targetAddress, toAddress, withFeePayer, options, transferable } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
 
@@ -288,6 +291,7 @@ export async function registerName(
       aptosConfig,
       sender: AccountAddress.from(sender).toString(),
       data,
+      withFeePayer,
       options,
     });
 
@@ -331,6 +335,7 @@ export async function registerName(
     aptosConfig,
     sender: AccountAddress.from(sender).toString(),
     data,
+    withFeePayer,
     options,
   });
 
@@ -411,6 +416,7 @@ export async function getPrimaryName(args: {
  * @param args.aptosConfig - The Aptos configuration object.
  * @param args.sender - The account that is sending the transaction.
  * @param args.name - The name to set as the primary name. If omitted, the function will clear the primary name.
+ * @param args.withFeePayer - Whether to build a fee-payer transaction.
  * @param args.options - Optional transaction generation options.
  * @returns A transaction object representing the operation.
  * @group Implementation
@@ -419,9 +425,10 @@ export async function setPrimaryName(args: {
   aptosConfig: AptosConfig;
   sender: AccountAddressInput;
   name?: string;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }): Promise<{ transaction: SimpleTransaction; data: InputEntryFunctionData }> {
-  const { aptosConfig, sender, name, options } = args;
+  const { aptosConfig, sender, name, withFeePayer, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
 
   if (!name) {
@@ -434,6 +441,7 @@ export async function setPrimaryName(args: {
       aptosConfig,
       sender: AccountAddress.from(sender).toString(),
       data,
+      withFeePayer,
       options,
     });
 
@@ -454,6 +462,7 @@ export async function setPrimaryName(args: {
     aptosConfig,
     sender: AccountAddress.from(sender).toString(),
     data,
+    withFeePayer,
     options,
   });
 
@@ -503,6 +512,7 @@ export async function getTargetAddress(args: {
  * @param args.sender - The account that is sending the transaction.
  * @param args.name - The name of the domain or subdomain to be set.
  * @param args.address - The address to be associated with the domain or subdomain.
+ * @param args.withFeePayer - Whether to build a fee-payer transaction.
  * @param args.options - Optional parameters for generating the transaction.
  *
  * @returns A transaction object representing the set target address operation.
@@ -513,9 +523,10 @@ export async function setTargetAddress(args: {
   sender: AccountAddressInput;
   name: string;
   address: AccountAddressInput;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }): Promise<{ transaction: SimpleTransaction; data: InputEntryFunctionData }> {
-  const { aptosConfig, sender, name, address, options } = args;
+  const { aptosConfig, sender, name, address, withFeePayer, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
 
@@ -528,6 +539,7 @@ export async function setTargetAddress(args: {
     aptosConfig,
     sender: AccountAddress.from(sender).toString(),
     data,
+    withFeePayer,
     options,
   });
 
@@ -545,6 +557,7 @@ export async function setTargetAddress(args: {
  * @param args.aptosConfig - The configuration settings for the Aptos network.
  * @param args.sender - The account that is sending the transaction.
  * @param args.name - The name of the domain or subdomain to clear the target address for.
+ * @param args.withFeePayer - Whether to build a fee-payer transaction.
  * @param args.options - Optional parameters for generating the transaction.
  *
  * @returns A transaction object representing the clear target address operation.
@@ -554,9 +567,10 @@ export async function clearTargetAddress(args: {
   aptosConfig: AptosConfig;
   sender: AccountAddressInput;
   name: string;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }): Promise<{ transaction: SimpleTransaction; data: InputEntryFunctionData }> {
-  const { aptosConfig, sender, name, options } = args;
+  const { aptosConfig, sender, name, withFeePayer, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
 
@@ -569,6 +583,7 @@ export async function clearTargetAddress(args: {
     aptosConfig,
     sender: AccountAddress.from(sender).toString(),
     data,
+    withFeePayer,
     options,
   });
 
@@ -920,6 +935,7 @@ export async function getANSGracePeriod(args: { aptosConfig: AptosConfig }): Pro
  * @param args.sender - The account that is sending the renewal transaction.
  * @param args.name - The name of the domain to renew.
  * @param args.years - The number of years to renew the domain for. Currently, only 1 year renewals are supported. (optional, default is 1)
+ * @param args.withFeePayer - Whether to build a fee-payer transaction.
  * @param args.options - Additional options for generating the transaction. (optional)
  * @throws Error if the name contains a subdomain or if the years parameter is not equal to 1.
  * @group Implementation
@@ -929,9 +945,10 @@ export async function renewDomain(args: {
   sender: AccountAddressInput;
   name: string;
   years?: 1;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }): Promise<{ transaction: SimpleTransaction; data: InputEntryFunctionData }> {
-  const { aptosConfig, sender, name, years = 1, options } = args;
+  const { aptosConfig, sender, name, years = 1, withFeePayer, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const renewalDuration = years * 31536000;
   const { domainName, subdomainName } = isValidANSName(name);
@@ -953,6 +970,7 @@ export async function renewDomain(args: {
     aptosConfig,
     sender: AccountAddress.from(sender).toString(),
     data,
+    withFeePayer,
     options,
   });
 

package/src/internal/coin.ts

@@ -22,6 +22,7 @@ const coinTransferAbi: EntryFunctionABI = {
  * @param args.recipient - The address of the account receiving the coins.
  * @param args.amount - The amount of coins to transfer.
  * @param args.coinType - (Optional) The type of coin to transfer, defaults to Aptos Coin if not specified.
+ * @param args.withFeePayer - Whether to build a fee-payer transaction.
  * @param args.options - (Optional) Options for generating the transaction.
  * @group Implementation
  */
@@ -31,9 +32,10 @@ export async function transferCoinTransaction(args: {
   recipient: AccountAddressInput;
   amount: AnyNumber;
   coinType?: MoveStructId;
+  withFeePayer?: boolean;
   options?: InputGenerateTransactionOptions;
 }): Promise<SimpleTransaction> {
-  const { aptosConfig, sender, recipient, amount, coinType, options } = args;
+  const { aptosConfig, sender, recipient, amount, coinType, withFeePayer, options } = args;
   const coinStructType = coinType ?? APTOS_COIN;
   return generateTransaction({
     aptosConfig,
@@ -44,6 +46,7 @@ export async function transferCoinTransaction(args: {
       functionArguments: [recipient, amount],
       abi: coinTransferAbi,
     },
+    withFeePayer,
     options,
   });
 }