@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/src/api/account.ts

@@ -1,26 +1,28 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { AptosConfig } from "./aptosConfig";
 import { AccountAddress, PrivateKey, Account as AccountModule, AccountAddressInput } from "../core";
 import {
   AccountData,
+  AnyNumber,
   GetAccountCoinsDataResponse,
   GetAccountCollectionsWithOwnedTokenResponse,
   GetAccountOwnedObjectsResponse,
   GetAccountOwnedTokensFromCollectionResponse,
   GetAccountOwnedTokensQueryResponse,
-  LedgerVersion,
+  LedgerVersionArg,
   MoveModuleBytecode,
   MoveResource,
   MoveStructId,
-  OrderBy,
+  OrderByArg,
   PaginationArgs,
-  TokenStandard,
+  TokenStandardArg,
   TransactionResponse,
+  WhereArg,
 } from "../types";
 import {
   deriveAccountFromPrivateKey,
+  getAccountCoinAmount,
   getAccountCoinsCount,
   getAccountCoinsData,
   getAccountCollectionsWithOwnedTokens,
@@ -37,16 +39,16 @@ import {
   getTransactions,
   lookupOriginalAccountAddress,
 } from "../internal/account";
+import { APTOS_COIN, ProcessorType } from "../utils/const";
+import { AptosConfig } from "./aptosConfig";
+import { waitForIndexerOnVersion } from "./utils";
+import { CurrentFungibleAssetBalancesBoolExp } from "../types/generated/types";
 
 /**
  * A class to query all `Account` related queries on Aptos.
  */
 export class Account {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
    * Queries the current state for an Aptos account given its account address
@@ -83,7 +85,7 @@ export class Account {
 
   async getAccountModules(args: {
     accountAddress: AccountAddressInput;
-    options?: PaginationArgs & LedgerVersion;
+    options?: PaginationArgs & LedgerVersionArg;
   }): Promise<MoveModuleBytecode[]> {
     return getModules({ aptosConfig: this.config, ...args });
   }
@@ -108,7 +110,7 @@ export class Account {
   async getAccountModule(args: {
     accountAddress: AccountAddressInput;
     moduleName: string;
-    options?: LedgerVersion;
+    options?: LedgerVersionArg;
   }): Promise<MoveModuleBytecode> {
     return getModule({ aptosConfig: this.config, ...args });
   }
@@ -149,7 +151,7 @@ export class Account {
    */
   async getAccountResources(args: {
     accountAddress: AccountAddressInput;
-    options?: PaginationArgs & LedgerVersion;
+    options?: PaginationArgs & LedgerVersionArg;
   }): Promise<MoveResource[]> {
     return getResources({ aptosConfig: this.config, ...args });
   }
@@ -168,14 +170,14 @@ export class Account {
    * @example An example of an account resource
    * ```
    * {
-   *    data: { value: 6 }
+   *    value: 6
    * }
    * ```
    */
   async getAccountResource<T extends {} = any>(args: {
     accountAddress: AccountAddressInput;
     resourceType: MoveStructId;
-    options?: LedgerVersion;
+    options?: LedgerVersionArg;
   }): Promise<T> {
     return getResource<T>({ aptosConfig: this.config, ...args });
   }
@@ -186,13 +188,21 @@ export class Account {
    * This handles both if the account's authentication key has been rotated or not.
    *
    * @param args.authenticationKey The authentication key
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
    * @returns Promise<AccountAddress> The accountAddress associated with the authentication key
    */
   async lookupOriginalAccountAddress(args: {
     authenticationKey: AccountAddressInput;
-    options?: LedgerVersion;
+    minimumLedgerVersion?: AnyNumber;
+    options?: LedgerVersionArg;
   }): Promise<AccountAddress> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
+
     return lookupOriginalAccountAddress({ aptosConfig: this.config, ...args });
   }
 
@@ -200,9 +210,18 @@ export class Account {
    * Queries the current count of tokens owned by an account
    *
    * @param args.accountAddress The account address
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns Current count of tokens owned by the account
    */
-  async getAccountTokensCount(args: { accountAddress: AccountAddressInput }): Promise<number> {
+  async getAccountTokensCount(args: {
+    accountAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountTokensCount({
       aptosConfig: this.config,
       ...args,
@@ -216,20 +235,23 @@ export class Account {
    * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
    *
    * @param args.accountAddress The account address we want to get the tokens for
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @param args.options.tokenStandard The NFT standard to query for
-   * @param args.options.pagination.offset The number token to start returning results from
-   * @param args.options.pagination.limit The number of results to return
+   * @param args.options.offset The number token to start returning results from
+   * @param args.options.limit The number of results to return
    * @param args.options.orderBy The order to sort the tokens by
    * @returns Tokens array with the token data
    */
   async getAccountOwnedTokens(args: {
     accountAddress: AccountAddressInput;
-    options?: {
-      tokenStandard?: TokenStandard;
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetAccountOwnedTokensQueryResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensQueryResponse[0]>;
   }): Promise<GetAccountOwnedTokensQueryResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountOwnedTokens({
       aptosConfig: this.config,
       ...args,
@@ -244,21 +266,24 @@ export class Account {
    *
    * @param args.accountAddress The account address we want to get the tokens for
    * @param args.collectionAddress The address of the collection being queried
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @param args.options.tokenStandard The NFT standard to query for
-   * @param args.options.pagination.offset The number token to start returning results from
-   * @param args.options.pagination.limit The number of results to return
+   * @param args.options.offset The number token to start returning results from
+   * @param args.options.limit The number of results to return
    * @param args.options.orderBy The order to sort the tokens by
    * @returns Tokens array with the token data
    */
   async getAccountOwnedTokensFromCollectionAddress(args: {
     accountAddress: AccountAddressInput;
     collectionAddress: AccountAddressInput;
-    options?: {
-      tokenStandard?: TokenStandard;
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetAccountOwnedTokensFromCollectionResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountOwnedTokensFromCollectionResponse[0]>;
   }): Promise<GetAccountOwnedTokensFromCollectionResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountOwnedTokensFromCollectionAddress({
       aptosConfig: this.config,
       ...args,
@@ -272,20 +297,23 @@ export class Account {
    * If you want to get only the token from a specific standard, you can pass an optional tokenStandard param
    *
    * @param args.accountAddress The account address we want to get the collections for
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @param args.options.tokenStandard The NFT standard to query for
-   * @param args.options.pagination.offset The number collection to start returning results from
-   * @param args.options.pagination.limit The number of results to return
+   * @param args.options.offset The number collection to start returning results from
+   * @param args.options.limit The number of results to return
    * @param args.options.orderBy The order to sort the tokens by
    * @returns Collections array with the collections data
    */
   async getAccountCollectionsWithOwnedTokens(args: {
     accountAddress: AccountAddressInput;
-    options?: {
-      tokenStandard?: TokenStandard;
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetAccountCollectionsWithOwnedTokenResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: TokenStandardArg & PaginationArgs & OrderByArg<GetAccountCollectionsWithOwnedTokenResponse[0]>;
   }): Promise<GetAccountCollectionsWithOwnedTokenResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountCollectionsWithOwnedTokens({
       aptosConfig: this.config,
       ...args,
@@ -296,9 +324,18 @@ export class Account {
    * Queries the current count of transactions submitted by an account
    *
    * @param args.accountAddress The account address we want to get the total count for
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns Current count of transactions made by an account
    */
-  async getAccountTransactionsCount(args: { accountAddress: AccountAddressInput }): Promise<number> {
+  async getAccountTransactionsCount(args: {
+    accountAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountTransactionsCount({
       aptosConfig: this.config,
       ...args,
@@ -309,18 +346,25 @@ export class Account {
    * Queries an account's coins data
    *
    * @param args.accountAddress The account address we want to get the coins data for
-   * @param args.options.pagination.offset The number coin to start returning results from
-   * @param args.options.pagination.limit The number of results to return
-   * @param args.options.orderBy The order to sort the coins by
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.options.offset optional. The number coin to start returning results from
+   * @param args.options.limit optional. The number of results to return
+   * @param args.options.orderBy optional. The order to sort the coins by
+   * @param args.options.where optional. Filter the results by
    * @returns Array with the coins data
    */
   async getAccountCoinsData(args: {
     accountAddress: AccountAddressInput;
-    options?: {
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetAccountCoinsDataResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs &
+      OrderByArg<GetAccountCoinsDataResponse[0]> &
+      WhereArg<CurrentFungibleAssetBalancesBoolExp>;
   }): Promise<GetAccountCoinsDataResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountCoinsData({
       aptosConfig: this.config,
       ...args,
@@ -331,28 +375,81 @@ export class Account {
    * Queries the current count of an account's coins aggregated
    *
    * @param args.accountAddress The account address we want to get the total count for
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
    * @returns Current count of the aggregated count of all account's coins
    */
-  async getAccountCoinsCount(args: { accountAddress: AccountAddressInput }): Promise<number> {
+  async getAccountCoinsCount(args: {
+    accountAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountCoinsCount({ aptosConfig: this.config, ...args });
   }
 
+  /**
+   * Queries the account's APT amount
+   *
+   * @param args.accountAddress The account address we want to get the total count for
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @returns Current amount of account's APT
+   */
+  async getAccountAPTAmount(args: {
+    accountAddress: AccountAddressInput;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
+    return getAccountCoinAmount({ aptosConfig: this.config, coinType: APTOS_COIN, ...args });
+  }
+
+  /**
+   * Queries the account's coin amount by the coin type
+   *
+   * @param args.accountAddress The account address we want to get the total count for
+   * @param args.coinType The coin type to query
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @returns Current amount of account's coin
+   */
+  async getAccountCoinAmount(args: {
+    accountAddress: AccountAddressInput;
+    coinType: MoveStructId;
+    minimumLedgerVersion?: AnyNumber;
+  }): Promise<number> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
+    return getAccountCoinAmount({ aptosConfig: this.config, ...args });
+  }
+
   /**
    * Queries an account's owned objects
    *
    * @param args.accountAddress The account address we want to get the objects for
-   * @param args.options.pagination.offset The number coin to start returning results from
-   * @param args.options.pagination.limit The number of results to return
-   * @param args.options.orderBy The order to sort the coins by
+   * @param args.minimumLedgerVersion Optional ledger version to sync up to, before querying
+   * @param args.options.offset The starting position to start returning results from
+   * @param args.options.limit The number of results to return
+   * @param args.options.orderBy The order to sort the objects by
    * @returns Objects array with the object data
    */
   async getAccountOwnedObjects(args: {
     accountAddress: AccountAddressInput;
-    options?: {
-      pagination?: PaginationArgs;
-      orderBy?: OrderBy<GetAccountOwnedObjectsResponse[0]>;
-    };
+    minimumLedgerVersion?: AnyNumber;
+    options?: PaginationArgs & OrderByArg<GetAccountOwnedObjectsResponse[0]>;
   }): Promise<GetAccountOwnedObjectsResponse> {
+    await waitForIndexerOnVersion({
+      config: this.config,
+      minimumLedgerVersion: args.minimumLedgerVersion,
+      processorTypes: [ProcessorType.ACCOUNT_TRANSACTION_PROCESSOR],
+    });
     return getAccountOwnedObjects({
       aptosConfig: this.config,
       ...args,

package/src/api/ans.ts

@@ -1,27 +1,44 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { RegisterNameParameters, getOwnerAddress, registerName } from "../internal/ans";
-import { InputSingleSignerTransaction } from "../transactions/types";
-import { MoveAddressType } from "../types";
+import { Account, AccountAddressInput } from "../core";
+import {
+  RegisterNameParameters,
+  getExpiration,
+  getOwnerAddress,
+  registerName,
+  getPrimaryName,
+  setPrimaryName,
+  getTargetAddress,
+  setTargetAddress,
+  renewDomain,
+  getName,
+  getAccountDomains,
+  GetAccountDomainsArgs,
+  GetAccountSubdomainsArgs,
+  getAccountSubdomains,
+  getAccountNames,
+  GetAccountNamesArgs,
+  getDomainSubdomains,
+  GetDomainSubdomainsArgs,
+} from "../internal/ans";
+import { GetANSNameResponse, MoveAddressType } from "../types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import { AptosConfig } from "./aptosConfig";
 
 /**
  * A class to handle all `ANS` operations
  */
 export class ANS {
-  readonly config: AptosConfig;
-
-  constructor(config: AptosConfig) {
-    this.config = config;
-  }
+  constructor(readonly config: AptosConfig) {}
 
   /**
-   * Retrieve the owner address of a domain name or subdomain name.
+   * Retrieve the owner address of a domain name or subdomain name from the contract.
    *
    * ```ts
-   * getOwnerAddress({name: "test.aptos"})
    * // Will return the owner address of "test.aptos.apt" or undefined
+   * const owner = await aptos.getOwnerAddress({name: "test.aptos"})
+   * // owner = 0x123...
    * ```
    *
    * @param args.name - A string of the name to retrieve
@@ -33,26 +50,245 @@ export class ANS {
   }
 
   /**
-   * Registers a new domain or subdomain name
+   * Retrieve the expiration time of a domain name or subdomain name from the contract.
+   *
+   * ```ts
+   * // Will return the expiration of "test.aptos.apt" or undefined
+   * const exp = await aptos.getExpiration({name: "test.aptos"})
+   * // new Date(exp) would give you the date in question: 2021-01-01T00:00:00.000Z
+   * ```
+   *
+   * @param args.name - A string of the name to retrieve
+   *
+   * @returns number as a unix timestamp in milliseconds.
+   */
+  async getExpiration(args: { name: string }): Promise<number | undefined> {
+    return getExpiration({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Retrieve the target address of a domain or subdomain name. This is the
+   * address the name points to for use on chain. Note, the target address can
+   * point to addresses that are not the owner of the name
+   *
+   * ```ts
+   * const targetAddr = await aptos.getTargetAddress({name: "test.aptos"})
+   * // targetAddr = 0x123...
+   * ```
+   *
+   * @param args.name - A string of the name: primary, primary.apt, secondary.primary, secondary.primary.apt, etc.
+   *
+   * @returns MoveAddressType if the name has a target, undefined otherwise
+   */
+  async getTargetAddress(args: { name: string }): Promise<MoveAddressType | undefined> {
+    return getTargetAddress({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Sets the target address of a domain or subdomain name. This is the
+   * address the name points to for use on chain. Note, the target address can
+   * point to addresses that are not the owner of the name
+   *
+   * ```ts
+   * await aptos.setTargetAddress({sender: alice, name: "test.aptos", address: bob.accountAddress})
+   * const address = await aptos.getTargetAddress({name: "test.aptos"})
+   * // address = bob.accountAddress
+   * ```
+   *
+   * @param args.name - A string of the name: test.aptos.apt, test.apt, test, test.aptos, etc.
+   * @param args.address - A AccountAddressInput of the address to set the domain or subdomain to
+   *
+   * @returns SingleSignerTransaction
+   */
+  async setTargetAddress(args: {
+    sender: Account;
+    name: string;
+    address: AccountAddressInput;
+    options?: InputGenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return setTargetAddress({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Retrieve the primary name for an account. An account can have
+   * multiple names that target it, but only a single name that is primary. An
+   * account also may not have a primary name.
+   *
+   * ```ts
+   * const name = await aptos.getPrimaryName({address: alice.accountAddress})
+   * // name = test.aptos
+   * ```
+   *
+   * @param args.address - A AccountAddressInput (address) of the account
+   *
+   * @returns a string if the account has a primary name, undefined otherwise
+   */
+  async getPrimaryName(args: { address: AccountAddressInput }): Promise<string | undefined> {
+    return getPrimaryName({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Sets the primary name for the sender. An account can have
+   * multiple names that target it, but only a single name that is primary. An
+   * account also may not have a primary name.
+   *
+   * ```ts
+   * await aptos.setPrimaryName({sender: alice, name: "test.aptos"})
+   * const primaryName = await aptos.getPrimaryName({address: alice.accountAddress})
+   * // primaryName = test.aptos
+   * ```
+   *
+   * @param args.sender - The sender account
+   * @param args.name - A string of the name: test, test.apt, test.aptos, test.aptos.apt, etc.
+   *
+   * @returns SingleSignerTransaction
+   */
+  async setPrimaryName(args: {
+    sender: Account;
+    name?: string;
+    options?: InputGenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return setPrimaryName({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Registers a new name
+   *
+   * ```ts
+   * // An example of registering a subdomain name assuming def.apt is already registered
+   * // and belongs to the sender alice.
+   *  const txn = aptos.registerName({
+   *    sender: alice,
+   *    name: "test.aptos.apt",
+   *    expiration: {
+   *      policy: "subdomain:independent",
+   *      expirationDate: Date.now() + 30 * 24 * 60 * 60 * 1000,
+   *    },
+   *  });
+   * ```
    *
    * @param args.sender - The sender account
-   * @param args.name - A string or {domainName: string, subdomainName?: string} of the name to register. This
-   * can be inclusive or exclusive of the .apt suffix.
-   * Examples include: "xyz", "xyz.apt", "xyz.kyc.apt", {domainName: "xyz"}, {domainName: "kyc", subdomainName: "xyz"}.
+   * @param args.name - A string of the name to register. This can be inclusive or exclusive of the .apt suffix.
+   * Examples include: "test", "test.apt", "test.aptos.apt", etc.
    * @param args.expiration  - An object with the expiration policy of the name.
    * @param args.expiration.policy - 'domain' | 'subdomain:follow-domain' | 'subdomain:independent'
    * - domain: Years is required and the name will expire after the given number of years.
    * - subdomain:follow-domain: The name will expire at the same time as the domain name.
    * - subdomain:independent: The name will expire at the given date.
+   * @param args.expiration.expirationDate - An epoch number in milliseconds of
+   * the date when the subdomain will expire. Only applicable when the policy is
+   * set to 'subdomain:independent'.
    * @param args.transferable  - Determines if the subdomain being minted is soul-bound. Applicable only to subdomains.
    * @param args.targetAddress optional - The address the domain name will resolve to. If not provided,
    * the sender's address will be used.
    * @param args.toAddress optional - The address to send the domain name to. If not provided,
    * the transaction will be sent to the router.
    *
-   * @returns InputSingleSignerTransaction
+   * @returns SingleSignerTransaction
    */
-  async registerName(args: Omit<RegisterNameParameters, "aptosConfig">): Promise<InputSingleSignerTransaction> {
+  async registerName(args: Omit<RegisterNameParameters, "aptosConfig">): Promise<SingleSignerTransaction> {
     return registerName({ aptosConfig: this.config, ...args });
   }
+
+  /**
+   * Renews a domain name
+   *
+   * Note: If a domain name was minted with V1 of the contract, it will automatically be upgraded to V2 via this transaction.
+   *
+   * ```ts
+   * await aptos.renewDomain({sender: alice, name: "test"})
+   * // test.apt will be renewed for one year
+   * ```
+   *
+   * @param args.sender - The sender account
+   * @param args.name - A string of the domain the subdomain will be under. The signer must be the domain owner.
+   * Subdomains cannot be renewed.
+   * @param args.years - The number of years to renew the name. Currently only one year is permitted.
+   *
+   * @returns SingleSignerTransaction
+   */
+  async renewDomain(args: {
+    sender: Account;
+    name: string;
+    years?: 1;
+    options?: InputGenerateTransactionOptions;
+  }): Promise<SingleSignerTransaction> {
+    return renewDomain({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Fetches a single name from the indexer
+   * @param args.name - A string of the name to retrieve, e.g. "test.aptos.apt"
+   * or "test.apt" or "test". Can be inclusive or exclusive of the .apt suffix.
+   * Can be a subdomain.
+   *
+   * @returns A promise of an ANSName or undefined
+   */
+  async getName(args: { name: string }): Promise<GetANSNameResponse[0] | undefined> {
+    return getName({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Fetches all  names for an account (both top level domains and subdomains)
+   *
+   * @param args
+   * @param args.accountAddress - A AccountAddressInput of the address to retrieve names for.
+   * @param args.options.offset - Optional, the offset to start from when fetching names
+   * @param args.options.limit - Optional, A number of the names to fetch per request
+   * @param args.options.orderBy - The order to sort the names by
+   * @param args.options.where - Additional filters to apply to the query
+   *
+   * @returns a promise of an array of ANSName
+   */
+  async getAccountNames(args: GetAccountNamesArgs): Promise<GetANSNameResponse> {
+    return getAccountNames({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Fetches all top level domain names for an account
+   *
+   * @param args
+   * @param args.accountAddress - A AccountAddressInput of the address to retrieve domain names for.
+   * @param args.options.offset - Optional, the offset to start from when fetching names
+   * @param args.options.limit - Optional, A number of the names to fetch per request
+   * @param args.options.orderBy - The order to sort the names by
+   * @param args.options.where - Additional filters to apply to the query
+   *
+   * @returns a promise of an array of ANSName
+   */
+  async getAccountDomains(args: GetAccountDomainsArgs): Promise<GetANSNameResponse> {
+    return getAccountDomains({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Fetches all subdomains names for an account
+   *
+   * @param args
+   * @param args.accountAddress - A AccountAddressInput of the address to retrieve subdomains names for.
+   * @param args.options.offset - Optional, the offset to start from when fetching names
+   * @param args.options.limit - Optional, A number of the names to fetch per request
+   * @param args.options.orderBy - The order to sort the names by
+   * @param args.options.where - Additional filters to apply to the query
+   *
+   * @returns a promise of an array of ANSName
+   */
+  async getAccountSubdomains(args: GetAccountSubdomainsArgs): Promise<GetANSNameResponse> {
+    return getAccountSubdomains({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Fetches all subdomains names for a given domain. Note, this will not return the domain itself.
+   *
+   * @param args
+   * @param args.domain - A string of the domain name: eg. "test.apt" or "test" (without the suffix of .apt)
+   * @param args.options.offset - Optional, the offset to start from when fetching names
+   * @param args.options.limit - Optional, A number of the names to fetch per request
+   * @param args.options.orderBy - The order to sort the names by
+   * @param args.options.where - Additional filters to apply to the query
+   *
+   * @returns a promise of an array of ANSName
+   */
+  async getDomainSubdomains(args: GetDomainSubdomainsArgs): Promise<GetANSNameResponse> {
+    return getDomainSubdomains({ aptosConfig: this.config, ...args });
+  }
 }