@aptos-labs/ts-sdk 1.0.0 → 1.1.0

package/src/api/transaction.ts

@@ -16,17 +16,44 @@ import {
   GasEstimation,
   HexInput,
   PaginationArgs,
+  PendingTransactionResponse,
   TransactionResponse,
   WaitForTransactionOptions,
 } from "../types";
-import { getSigningMessage } from "../internal/transactionSubmission";
-import { AnyRawTransaction } from "../transactions";
+import {
+  getSigningMessage,
+  publicPackageTransaction,
+  rotateAuthKey,
+  signAndSubmitTransaction,
+  signTransaction,
+} from "../internal/transactionSubmission";
+import {
+  AccountAuthenticator,
+  AnyRawTransaction,
+  InputGenerateTransactionOptions,
+  InputGenerateTransactionPayloadData,
+  SimpleTransaction,
+} from "../transactions";
+import { AccountAddressInput, Account, PrivateKey } from "../core";
+import { TransactionWorker } from "../transactions/management";
+import { Build } from "./transactionSubmission/build";
+import { Simulate } from "./transactionSubmission/simulate";
+import { Submit } from "./transactionSubmission/submit";
 
 export class Transaction {
   readonly config: AptosConfig;
 
+  readonly build: Build;
+
+  readonly simulate: Simulate;
+
+  readonly submit: Submit;
+
   constructor(config: AptosConfig) {
     this.config = config;
+    this.build = new Build(this.config);
+    this.simulate = new Simulate(this.config);
+    this.submit = new Submit(this.config);
   }
 
   /**
@@ -154,4 +181,147 @@ export class Transaction {
   getSigningMessage(args: { transaction: AnyRawTransaction }): Uint8Array {
     return getSigningMessage(args);
   }
+
+  /**
+   * Generates a transaction to publish a move package to chain.
+   *
+   * To get the `metadataBytes` and `byteCode`, can compile using Aptos CLI with command
+   * `aptos move compile --save-metadata ...`,
+   * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}
+   *
+   * @param args.account The publisher account
+   * @param args.metadataBytes The package metadata bytes
+   * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order
+   *
+   * @returns A SimpleTransaction that can be simulated or submitted to chain
+   */
+  async publishPackageTransaction(args: {
+    account: AccountAddressInput;
+    metadataBytes: HexInput;
+    moduleBytecode: Array<HexInput>;
+    options?: InputGenerateTransactionOptions;
+  }): Promise<SimpleTransaction> {
+    return publicPackageTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Rotate an account's auth key. After rotation, only the new private key can be used to sign txns for
+   * the account.
+   * Note: Only legacy Ed25519 scheme is supported for now.
+   * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}
+   * @param args.fromAccount The account to rotate the auth key for
+   * @param args.toNewPrivateKey The new private key to rotate to
+   *
+   * @returns PendingTransactionResponse
+   */
+  async rotateAuthKey(args: { fromAccount: Account; toNewPrivateKey: PrivateKey }): Promise<TransactionResponse> {
+    return rotateAuthKey({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Sign a transaction that can later be submitted to chain
+   *
+   * @param args.signer The signer account
+   * @param args.transaction A raw transaction to sign on
+   *
+   * @returns AccountAuthenticator
+   */
+  // eslint-disable-next-line class-methods-use-this
+  sign(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+    return signTransaction({
+      ...args,
+    });
+  }
+
+  /**
+   * Sign a transaction as a fee payer that can later be submitted to chain
+   *
+   * @param args.signer The fee payer signer account
+   * @param args.transaction A raw transaction to sign on
+   *
+   * @returns AccountAuthenticator
+   */
+  // eslint-disable-next-line class-methods-use-this
+  signAsFeePayer(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,
+    });
+  }
+
+  // TRANSACTION SUBMISSION //
+
+  /**
+   * Batch transactions for a single account.
+   *
+   * This function uses a transaction worker that receives payloads to be processed
+   * and submitted to chain.
+   * Note that this process is best for submitting multiple transactions that
+   * dont rely on each other, i.e batch funds, batch token mints, etc.
+   *
+   * If any worker failure, the functions throws an error.
+   *
+   * @param args.sender The sender account to sign and submit the transaction
+   * @param args.data An array of transaction payloads
+   * @param args.options optional. Transaction generation configurations (excluding accountSequenceNumber)
+   *
+   * @return void. Throws if any error
+   */
+  async batchTransactionsForSingleAccount(args: {
+    sender: Account;
+    data: InputGenerateTransactionPayloadData[];
+    options?: Omit<InputGenerateTransactionOptions, "accountSequenceNumber">;
+  }): Promise<void> {
+    try {
+      const { sender, data, options } = args;
+      const transactionWorker = new TransactionWorker(this.config, sender);
+
+      transactionWorker.start();
+
+      for (const d of data) {
+        /* eslint-disable no-await-in-loop */
+        await transactionWorker.push(d, options);
+      }
+    } catch (error: any) {
+      throw new Error(`failed to submit transactions with error: ${error}`);
+    }
+  }
+
+  /**
+   * Sign and submit a single signer transaction to chain
+   *
+   * @param args.signer The signer account to sign the transaction
+   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
+   * ```
+   * {
+   *  rawTransaction: RawTransaction,
+   *  secondarySignerAddresses? : Array<AccountAddress>,
+   *  feePayerAddress?: AccountAddress
+   * }
+   * ```
+   *
+   * @return PendingTransactionResponse
+   */
+  async signAndSubmitTransaction(args: {
+    signer: Account;
+    transaction: AnyRawTransaction;
+  }): Promise<PendingTransactionResponse> {
+    const { signer, transaction } = args;
+    return signAndSubmitTransaction({
+      aptosConfig: this.config,
+      signer,
+      transaction,
+    });
+  }
 }

package/src/api/transactionSubmission/build.ts

@@ -6,7 +6,7 @@ import { generateTransaction } from "../../internal/transactionSubmission";
 import {
   InputGenerateTransactionPayloadData,
   InputGenerateTransactionOptions,
-  SingleSignerTransaction,
+  SimpleTransaction,
   MultiAgentTransaction,
 } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";
@@ -21,16 +21,37 @@ export class Build {
     this.config = config;
   }
 
-  async transaction(args: {
+  /**
+   * Build a simple transaction
+   *
+   * @param args.sender The sender account address
+   * @param args.data The transaction data
+   * @param args.options optional. Optional transaction configurations
+   * @param args.withFeePayer optional. Whether there is a fee payer for the transaction
+   *
+   * @returns SimpleTransaction
+   */
+  async simple(args: {
     sender: AccountAddressInput;
     data: InputGenerateTransactionPayloadData;
     options?: InputGenerateTransactionOptions;
     withFeePayer?: boolean;
-  }): Promise<SingleSignerTransaction> {
+  }): Promise<SimpleTransaction> {
     return generateTransaction({ aptosConfig: this.config, ...args });
   }
 
-  async multiAgentTransaction(args: {
+  /**
+   * Build a multi agent transaction
+   *
+   * @param args.sender The sender account address
+   * @param args.data The transaction data
+   * @param args.secondarySignerAddresses An array of the secondary signers account addresses
+   * @param args.options optional. Optional transaction configurations
+   * @param args.withFeePayer optional. Whether there is a fee payer for the transaction
+   *
+   * @returns MultiAgentTransaction
+   */
+  async multiAgent(args: {
     sender: AccountAddressInput;
     data: InputGenerateTransactionPayloadData;
     secondarySignerAddresses: AccountAddressInput[];

package/src/api/transactionSubmission/helpers.ts

@@ -0,0 +1,31 @@
+export function ValidateFeePayerDataOnSubmission(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;
+}
+
+export function ValidateFeePayerDataOnSimulation(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/simulate.ts

@@ -6,6 +6,7 @@ import { simulateTransaction } from "../../internal/transactionSubmission";
 import { AnyRawTransaction, InputSimulateTransactionOptions } from "../../transactions";
 import { UserTransactionResponse } from "../../types";
 import { AptosConfig } from "../aptosConfig";
+import { ValidateFeePayerDataOnSimulation } from "./helpers";
 
 /**
  * A class to handle all `Simulate` transaction operations
@@ -17,8 +18,18 @@ export class Simulate {
     this.config = config;
   }
 
-  @ValidateFeePayerData
-  async transaction(args: {
+  /**
+   * Simulate a simple transaction
+   *
+   * @param args.signerPublicKey The signer public key
+   * @param args.transaction An instance of a raw transaction
+   * @param args.options optional. Optional transaction configurations
+   * @param args.feePayerPublicKey optional. The fee payer public key if it is a fee payer transaction
+   *
+   * @returns Array<UserTransactionResponse>
+   */
+  @ValidateFeePayerDataOnSimulation
+  async simple(args: {
     signerPublicKey: PublicKey;
     transaction: AnyRawTransaction;
     feePayerPublicKey?: PublicKey;
@@ -27,8 +38,19 @@ export class Simulate {
     return simulateTransaction({ aptosConfig: this.config, ...args });
   }
 
-  @ValidateFeePayerData
-  async multiAgentTransaction(args: {
+  /**
+   * Simulate a multi agent transaction
+   *
+   * @param args.signerPublicKey The signer public key
+   * @param args.transaction An instance of a raw transaction
+   * @param args.secondarySignersPublicKeys An array of the secondary signers public keys
+   * @param args.options optional. Optional transaction configurations
+   * @param args.feePayerPublicKey optional. The fee payer public key if it is a fee payer transaction
+   *
+   * @returns Array<UserTransactionResponse>
+   */
+  @ValidateFeePayerDataOnSimulation
+  async multiAgent(args: {
     signerPublicKey: PublicKey;
     transaction: AnyRawTransaction;
     secondarySignersPublicKeys: Array<PublicKey>;
@@ -38,19 +60,3 @@ export class Simulate {
     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

@@ -5,6 +5,7 @@ import { submitTransaction } from "../../internal/transactionSubmission";
 import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
 import { PendingTransactionResponse } from "../../types";
 import { AptosConfig } from "../aptosConfig";
+import { ValidateFeePayerDataOnSubmission } from "./helpers";
 
 /**
  * A class to handle all `Submit` transaction operations
@@ -16,8 +17,17 @@ export class Submit {
     this.config = config;
   }
 
-  @ValidateFeePayerData
-  async transaction(args: {
+  /**
+   * Submit a simple transaction
+   *
+   * @param args.transaction An instance of a raw transaction
+   * @param args.senderAuthenticator optional. The sender account authenticator
+   * @param args.feePayerAuthenticator optional. The fee payer account authenticator if it is a fee payer transaction
+   *
+   * @returns PendingTransactionResponse
+   */
+  @ValidateFeePayerDataOnSubmission
+  async simple(args: {
     transaction: AnyRawTransaction;
     senderAuthenticator: AccountAuthenticator;
     feePayerAuthenticator?: AccountAuthenticator;
@@ -25,8 +35,18 @@ export class Submit {
     return submitTransaction({ aptosConfig: this.config, ...args });
   }
 
-  @ValidateFeePayerData
-  async multiAgentTransaction(args: {
+  /**
+   * Submit a multi agent transaction
+   *
+   * @param args.transaction An instance of a raw transaction
+   * @param args.senderAuthenticator optional. The sender account authenticator
+   * @param args.additionalSignersAuthenticators An array of the secondary signers account authenticators
+   * @param args.feePayerAuthenticator optional. The fee payer account authenticator if it is a fee payer transaction
+   *
+   * @returns PendingTransactionResponse
+   */
+  @ValidateFeePayerDataOnSubmission
+  async multiAgent(args: {
     transaction: AnyRawTransaction;
     senderAuthenticator: AccountAuthenticator;
     additionalSignersAuthenticators: Array<AccountAuthenticator>;
@@ -35,19 +55,3 @@ export class Submit {
     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;
-}

package/src/client/core.ts

@@ -28,7 +28,7 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
   const { url, method, body, contentType, params, overrides } = options;
   const headers: Record<string, string | AnyNumber | boolean | undefined> = {
     ...overrides?.HEADERS,
-    "x-aptos-client": `aptos-ts-sdk/${VERSION}`,
+    "x-aptos-client": `aptos-typescript-sdk/${VERSION}`,
     "content-type": contentType ?? MimeType.JSON,
   };
 

package/src/core/account.ts

@@ -64,8 +64,8 @@ export class Account {
    *
    * @param args.privateKey PrivateKey - private key of the account
    * @param args.address AccountAddress - address of the account
-   * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.
-   * Defaults to deriving an authentication key with a Unified scheme
+   * @param args.legacy optional. If set to false, the keypair authentication keys will be derived with a unified scheme.
+   * Defaults to deriving an authentication key with the legacy scheme.
    *
    * This method is private because it should only be called by the factory static methods.
    * @returns Account

package/src/internal/ans.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { Account, AccountAddress, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
 import { GetANSNameResponse, MoveAddressType, MoveValue, OrderByArg, PaginationArgs, WhereArg } from "../types";
 import { GetNamesQuery } from "../types/generated/operations";
 import { GetNames } from "../types/generated/queries";
@@ -130,7 +130,7 @@ export interface RegisterNameParameters {
   options?: InputGenerateTransactionOptions;
 }
 
-export async function registerName(args: RegisterNameParameters): Promise<SingleSignerTransaction> {
+export async function registerName(args: RegisterNameParameters): Promise<SimpleTransaction> {
   const { aptosConfig, expiration, name, sender, targetAddress, toAddress, options, transferable } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
@@ -257,7 +257,7 @@ export async function setPrimaryName(args: {
   sender: Account;
   name?: string;
   options?: InputGenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+}): Promise<SimpleTransaction> {
   const { aptosConfig, sender, name, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
 
@@ -316,7 +316,7 @@ export async function setTargetAddress(args: {
   name: string;
   address: AccountAddressInput;
   options?: InputGenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+}): Promise<SimpleTransaction> {
   const { aptosConfig, sender, name, address, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const { domainName, subdomainName } = isValidANSName(name);
@@ -533,7 +533,7 @@ export async function renewDomain(args: {
   name: string;
   years?: 1;
   options?: InputGenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+}): Promise<SimpleTransaction> {
   const { aptosConfig, sender, name, years = 1, options } = args;
   const routerAddress = getRouterAddress(aptosConfig);
   const renewalDuration = years * 31536000;

package/src/internal/coin.ts

@@ -1,6 +1,6 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { Account, AccountAddressInput } from "../core";
-import { InputGenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions/types";
 import { AnyNumber, MoveStructId } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
@@ -12,7 +12,7 @@ export async function transferCoinTransaction(args: {
   amount: AnyNumber;
   coinType?: MoveStructId;
   options?: InputGenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+}): Promise<SimpleTransaction> {
   const { aptosConfig, sender, recipient, amount, coinType, options } = args;
   const coinStructType = coinType ?? APTOS_COIN;
   const transaction = await generateTransaction({