@aptos-labs/ts-sdk 0.0.6 → 0.0.7

package/src/api/ans.ts

@@ -1,9 +1,29 @@
 // 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";
 
 /**
@@ -17,11 +37,12 @@ export class ANS {
   }
 
   /**
-   * 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 +54,244 @@ 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 seconds.
+   */
+  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.toString})
+   * const address = await aptos.getTargetAddress({name: "test.aptos"})
+   * // address = bob.accountAddress.toString()
+   * ```
+   *
+   * @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.toString()})
+   * // 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.toString()})
+   * // 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 | null;
+    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: new Date(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 - A javascript date of 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.pagination.offset - Optional, the offset to start from when fetching names
+   * @param args.options.pagination.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.pagination.offset - Optional, the offset to start from when fetching names
+   * @param args.options.pagination.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.pagination.offset - Optional, the offset to start from when fetching names
+   * @param args.options.pagination.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.pagination.offset - Optional, the offset to start from when fetching names
+   * @param args.options.pagination.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 });
+  }
 }

package/src/api/aptos.ts

@@ -13,6 +13,10 @@ import { ANS } from "./ans";
 import { Staking } from "./staking";
 import { Transaction } from "./transaction";
 import { TransactionSubmission } from "./transactionSubmission";
+import { Build } from "./transactionSubmission/build";
+import { Sign } from "./transactionSubmission/sign";
+import { Simulate } from "./transactionSubmission/simulate";
+import { Submit } from "./transactionSubmission/submit";
 
 /**
  * This class is the main entry point into Aptos's
@@ -46,6 +50,14 @@ export class Aptos {
 
   readonly transactionSubmission: TransactionSubmission;
 
+  readonly build: Build;
+
+  readonly sign: Sign;
+
+  readonly simulate: Simulate;
+
+  readonly submit: Submit;
+
   constructor(settings?: AptosConfig) {
     this.config = new AptosConfig(settings);
     this.account = new Account(this.config);
@@ -59,6 +71,10 @@ export class Aptos {
     this.staking = new Staking(this.config);
     this.transaction = new Transaction(this.config);
     this.transactionSubmission = new TransactionSubmission(this.config);
+    this.build = new Build(this.config);
+    this.sign = new Sign(this.config);
+    this.simulate = new Simulate(this.config);
+    this.submit = new Submit(this.config);
   }
 }
 
@@ -107,3 +123,7 @@ applyMixin(Aptos, General, "general");
 applyMixin(Aptos, Staking, "staking");
 applyMixin(Aptos, Transaction, "transaction");
 applyMixin(Aptos, TransactionSubmission, "transactionSubmission");
+applyMixin(Aptos, Build, "build");
+applyMixin(Aptos, Sign, "sign");
+applyMixin(Aptos, Simulate, "simulate");
+applyMixin(Aptos, Submit, "submit");

package/src/api/coin.ts

@@ -4,7 +4,7 @@
 import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput } from "../core";
 import { transferCoinTransaction } from "../internal/coin";
-import { InputSingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
+import { SingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
 import { AnyNumber, MoveStructId } from "../types";
 
 /**
@@ -33,7 +33,7 @@ export class Coin {
     amount: AnyNumber;
     coinType?: MoveStructId;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return transferCoinTransaction({ aptosConfig: this.config, ...args });
   }
 }

package/src/api/digitalAsset.ts

@@ -13,7 +13,7 @@ import {
 } from "../types";
 import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
 import {
   CreateCollectionOptions,
   createCollectionTransaction,
@@ -69,7 +69,7 @@ export class DigitalAsset {
       uri: string;
       options?: InputGenerateTransactionOptions;
     } & CreateCollectionOptions,
-  ): Promise<InputSingleSignerTransaction> {
+  ): Promise<SingleSignerTransaction> {
     return createCollectionTransaction({ aptosConfig: this.config, ...args });
   }
 
@@ -133,7 +133,7 @@ export class DigitalAsset {
     name: string;
     uri: string;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return mintTokenTransaction({ aptosConfig: this.config, ...args });
   }
 

package/src/api/transactionSubmission/build.ts

@@ -0,0 +1,42 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AccountAddressInput } from "../../core";
+import { generateTransaction } from "../../internal/transactionSubmission";
+import {
+  InputGenerateTransactionPayloadData,
+  InputGenerateTransactionOptions,
+  SingleSignerTransaction,
+  MultiAgentTransaction,
+} from "../../transactions";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Build` transaction operations
+ */
+export class Build {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  async transaction(args: {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+  }): Promise<SingleSignerTransaction> {
+    return generateTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  async multiAgentTransaction(args: {
+    sender: AccountAddressInput;
+    data: InputGenerateTransactionPayloadData;
+    secondarySignerAddresses: AccountAddressInput[];
+    options?: InputGenerateTransactionOptions;
+    withFeePayer?: boolean;
+  }): Promise<MultiAgentTransaction> {
+    return generateTransaction({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/transactionSubmission/sign.ts

@@ -0,0 +1,44 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Account } from "../../core";
+import { signTransaction } from "../../internal/transactionSubmission";
+import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Sign` transaction operations
+ */
+export class Sign {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  transaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+    return signTransaction({
+      ...args,
+    });
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  transactionAsFeePayer(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+    const { signer, transaction } = args;
+
+    // if transaction doesnt hold a "feePayerAddress" prop it means
+    // this is not a fee payer transaction
+    if (!transaction.feePayerAddress) {
+      throw new Error(`Transaction ${transaction} is not a Fee Payer transaction`);
+    }
+
+    // Set the feePayerAddress to the signer account address
+    transaction.feePayerAddress = signer.accountAddress;
+
+    return signTransaction({
+      signer,
+      transaction,
+    });
+  }
+}

package/src/api/transactionSubmission/simulate.ts

@@ -0,0 +1,56 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { PublicKey } from "../../core";
+import { simulateTransaction } from "../../internal/transactionSubmission";
+import { AnyRawTransaction, InputSimulateTransactionOptions } from "../../transactions";
+import { UserTransactionResponse } from "../../types";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Simulate` transaction operations
+ */
+export class Simulate {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  @ValidateFeePayerData
+  async transaction(args: {
+    signerPublicKey: PublicKey;
+    transaction: AnyRawTransaction;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+  }): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  @ValidateFeePayerData
+  async multiAgentTransaction(args: {
+    signerPublicKey: PublicKey;
+    transaction: AnyRawTransaction;
+    secondarySignersPublicKeys: Array<PublicKey>;
+    feePayerPublicKey?: PublicKey;
+    options?: InputSimulateTransactionOptions;
+  }): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ aptosConfig: this.config, ...args });
+  }
+}
+
+function ValidateFeePayerData(target: unknown, propertyKey: string, descriptor: PropertyDescriptor) {
+  const originalMethod = descriptor.value;
+  /* eslint-disable-next-line func-names, no-param-reassign */
+  descriptor.value = async function (...args: any[]) {
+    const [methodArgs] = args;
+
+    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerPublicKey) {
+      throw new Error("You are simulating a Fee Payer transaction but missing the feePayerPublicKey");
+    }
+
+    return originalMethod.apply(this, args);
+  };
+
+  return descriptor;
+}

package/src/api/transactionSubmission/submit.ts

@@ -0,0 +1,53 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { submitTransaction } from "../../internal/transactionSubmission";
+import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
+import { PendingTransactionResponse } from "../../types";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Submit` transaction operations
+ */
+export class Submit {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  @ValidateFeePayerData
+  async transaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    feePayerAuthenticator?: AccountAuthenticator;
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  @ValidateFeePayerData
+  async multiAgentTransaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    additionalSignersAuthenticators: Array<AccountAuthenticator>;
+    feePayerAuthenticator?: AccountAuthenticator;
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+}
+
+function ValidateFeePayerData(target: unknown, propertyKey: string, descriptor: PropertyDescriptor) {
+  const originalMethod = descriptor.value;
+  /* eslint-disable-next-line func-names, no-param-reassign */
+  descriptor.value = async function (...args: any[]) {
+    const [methodArgs] = args;
+
+    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerAuthenticator) {
+      throw new Error("You are submitting a Fee Payer transaction but missing the feePayerAuthenticator");
+    }
+
+    return originalMethod.apply(this, args);
+  };
+
+  return descriptor;
+}