@aptos-labs/ts-sdk 0.0.0

package/src/internal/transaction.ts

@@ -0,0 +1,245 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/transaction}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * transaction namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { AptosApiError, getAptosFullNode, paginateWithCursor } from "../client";
+import {
+  TransactionResponseType,
+  type AnyNumber,
+  type GasEstimation,
+  type HexInput,
+  type PaginationArgs,
+  type TransactionResponse,
+} from "../types";
+import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
+import { sleep } from "../utils/helpers";
+import { memoizeAsync } from "../utils/memoize";
+import { getIndexerLastSuccessVersion } from "./general";
+
+export async function getTransactions(args: {
+  aptosConfig: AptosConfig;
+  options?: PaginationArgs;
+}): Promise<TransactionResponse[]> {
+  const { aptosConfig, options } = args;
+  return paginateWithCursor<{}, TransactionResponse[]>({
+    aptosConfig,
+    originMethod: "getTransactions",
+    path: "transactions",
+    params: { start: options?.offset, limit: options?.limit },
+  });
+}
+
+export async function getGasPriceEstimation(args: { aptosConfig: AptosConfig }) {
+  const { aptosConfig } = args;
+
+  return memoizeAsync(
+    async () => {
+      const { data } = await getAptosFullNode<{}, GasEstimation>({
+        aptosConfig,
+        originMethod: "getGasPriceEstimation",
+        path: "estimate_gas_price",
+      });
+      return data;
+    },
+    `gas-price-${aptosConfig.network}`,
+    1000 * 60 * 5, // 5 minutes
+  )();
+}
+
+export async function getTransactionByVersion(args: {
+  aptosConfig: AptosConfig;
+  ledgerVersion: AnyNumber;
+}): Promise<TransactionResponse> {
+  const { aptosConfig, ledgerVersion } = args;
+  const { data } = await getAptosFullNode<{}, TransactionResponse>({
+    aptosConfig,
+    originMethod: "getTransactionByVersion",
+    path: `transactions/by_version/${ledgerVersion}`,
+  });
+  return data;
+}
+
+export async function getTransactionByHash(args: {
+  aptosConfig: AptosConfig;
+  transactionHash: HexInput;
+}): Promise<TransactionResponse> {
+  const { aptosConfig, transactionHash } = args;
+  const { data } = await getAptosFullNode<{}, TransactionResponse>({
+    aptosConfig,
+    path: `transactions/by_hash/${transactionHash}`,
+    originMethod: "getTransactionByHash",
+  });
+  return data;
+}
+
+export async function isTransactionPending(args: {
+  aptosConfig: AptosConfig;
+  transactionHash: HexInput;
+}): Promise<boolean> {
+  const { aptosConfig, transactionHash } = args;
+  try {
+    const transaction = await getTransactionByHash({ aptosConfig, transactionHash });
+    return transaction.type === TransactionResponseType.Pending;
+  } catch (e: any) {
+    if (e?.status === 404) {
+      return true;
+    }
+    throw e;
+  }
+}
+
+export async function waitForTransaction(args: {
+  aptosConfig: AptosConfig;
+  transactionHash: HexInput;
+  options?: { timeoutSecs?: number; checkSuccess?: boolean; indexerVersionCheck?: boolean };
+}): Promise<TransactionResponse> {
+  const { aptosConfig, transactionHash, options } = args;
+  const timeoutSecs = options?.timeoutSecs ?? DEFAULT_TXN_TIMEOUT_SEC;
+  const checkSuccess = options?.checkSuccess ?? true;
+  const indexerVersionCheck = options?.indexerVersionCheck ?? true;
+
+  let isPending = true;
+  let timeElapsed = 0;
+  let lastTxn: TransactionResponse | undefined;
+  let lastError: AptosApiError | undefined;
+  let backoffIntervalMs = 200;
+  const backoffMultiplier = 1.5;
+
+  while (isPending) {
+    if (timeElapsed >= timeoutSecs) {
+      break;
+    }
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      lastTxn = await getTransactionByHash({ aptosConfig, transactionHash });
+
+      isPending = lastTxn.type === TransactionResponseType.Pending;
+
+      if (!isPending) {
+        break;
+      }
+    } catch (e) {
+      // In short, this means we will retry if it was an AptosApiError and the code was 404 or 5xx.
+      const isAptosApiError = e instanceof AptosApiError;
+      if (!isAptosApiError) {
+        throw e; // This would be unexpected
+      }
+      lastError = e;
+      const isRequestError = e.status !== 404 && e.status >= 400 && e.status < 500;
+      if (isRequestError) {
+        throw e;
+      }
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(backoffIntervalMs);
+    timeElapsed += backoffIntervalMs / 1000; // Convert to seconds
+    backoffIntervalMs *= backoffMultiplier;
+  }
+
+  // There is a chance that lastTxn is still undefined. Let's throw the last error otherwise a WaitForTransactionError
+  if (lastTxn === undefined) {
+    if (lastError) {
+      throw lastError;
+    } else {
+      throw new WaitForTransactionError(
+        `Fetching transaction ${transactionHash} failed and timed out after ${timeoutSecs} seconds`,
+        lastTxn,
+      );
+    }
+  }
+
+  if (lastTxn.type === TransactionResponseType.Pending) {
+    throw new WaitForTransactionError(
+      `Transaction ${transactionHash} timed out in pending state after ${timeoutSecs} seconds`,
+      lastTxn,
+    );
+  }
+  if (!checkSuccess) {
+    return lastTxn;
+  }
+  if (!lastTxn.success) {
+    throw new FailedTransactionError(
+      `Transaction ${transactionHash} failed with an error: ${(lastTxn as any).vm_status}`,
+      lastTxn,
+    );
+  }
+
+  // Make sure indexer is synced with the latest ledger version
+  if (indexerVersionCheck) {
+    try {
+      await waitForLastSuccessIndexerVersionSync({ aptosConfig, ledgerVersion: Number(lastTxn.version) });
+    } catch (_e) {
+      throw new WaitForTransactionError(
+        // eslint-disable-next-line max-len
+        `Transaction ${transactionHash} committed, but timed out waiting for indexer to sync with ledger version ${lastTxn.version}.` +
+          "You can disable this check by setting `indexerVersionCheck` to false in the `extraArgs` parameter.",
+        lastTxn,
+      );
+    }
+  }
+
+  return lastTxn;
+}
+
+/**
+ * Waits for the indexer to sync up to the ledgerVersion. Timeout is 3 seconds.
+ */
+async function waitForLastSuccessIndexerVersionSync(args: {
+  aptosConfig: AptosConfig;
+  ledgerVersion: number;
+}): Promise<void> {
+  const { aptosConfig, ledgerVersion } = args;
+  const timeoutMilliseconds = 3000; // 3 seconds
+  const startTime = new Date().getTime();
+  let indexerVersion = -1;
+
+  while (indexerVersion < ledgerVersion) {
+    // check for timeout
+    if (new Date().getTime() - startTime > timeoutMilliseconds) {
+      throw new Error("waitForLastSuccessIndexerVersionSync timeout");
+    }
+
+    // eslint-disable-next-line no-await-in-loop
+    indexerVersion = await getIndexerLastSuccessVersion({ aptosConfig });
+    if (indexerVersion >= ledgerVersion) {
+      // break out immediately if we are synced
+      break;
+    }
+
+    // eslint-disable-next-line no-await-in-loop
+    await sleep(200);
+  }
+}
+
+/**
+ * This error is used by `waitForTransaction` when waiting for a
+ * transaction to time out or when the transaction response is undefined
+ */
+export class WaitForTransactionError extends Error {
+  public readonly lastSubmittedTransaction: TransactionResponse | undefined;
+
+  constructor(message: string, lastSubmittedTransaction: TransactionResponse | undefined) {
+    super(message);
+    this.lastSubmittedTransaction = lastSubmittedTransaction;
+  }
+}
+
+/**
+ * This error is used by `waitForTransaction` if `checkSuccess` is true.
+ * See that function for more information.
+ */
+export class FailedTransactionError extends Error {
+  public readonly transaction: TransactionResponse;
+
+  constructor(message: string, transaction: TransactionResponse) {
+    super(message);
+    this.transaction = transaction;
+  }
+}

package/src/internal/transactionSubmission.ts

@@ -0,0 +1,162 @@
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/transaction_submission}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * transaction_submission namespace and without having a dependency cycle error.
+ */
+
+import { AptosConfig } from "../api/aptosConfig";
+import { postAptosFullNode } from "../client";
+import { Account } from "../core/account";
+import { AccountAuthenticator } from "../transactions/authenticator/account";
+import {
+  buildTransaction,
+  generateTransactionPayload,
+  generateSignedTransactionForSimulation,
+  generateSignedTransaction,
+  sign,
+} from "../transactions/transaction_builder/transaction_builder";
+import { GenerateTransactionInput, AnyRawTransaction, SimulateTransactionData } from "../transactions/types";
+import { UserTransactionResponse, PendingTransactionResponse, MimeType } from "../types";
+
+/**
+ * Generates any transaction by passing in the required arguments
+ *
+ * @param args.sender The transaction sender's account address as a HexInput
+ * @param args.data EntryFunctionData | ScriptData | MultiSigData
+ * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction
+ * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions
+ * @param args.options optional. GenerateTransactionOptions type
+ *
+ * @example
+ * For a single signer entry function
+ * move function name, move function type arguments, move function arguments
+ * `
+ * data: {
+ *  function:"0x1::aptos_account::transfer",
+ *  type_arguments:[]
+ *  arguments:[receiverAddress,10]
+ * }
+ * `
+ *
+ * @example
+ * For a single signer script function
+ * module bytecode, move function type arguments, move function arguments
+ * ```
+ * data: {
+ *  bytecode:"0x001234567",
+ *  type_arguments:[],
+ *  arguments:[receiverAddress,10]
+ * }
+ * ```
+ *
+ * @return A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+ * ```
+ * {
+ *  rawTransaction: Uint8Array,
+ *  secondarySignerAddresses? : Array<AccountAddress>,
+ *  feePayerAddress?: AccountAddress
+ * }
+ * ```
+ */
+export async function generateTransaction(
+  args: { aptosConfig: AptosConfig } & GenerateTransactionInput,
+): Promise<AnyRawTransaction> {
+  const { aptosConfig, sender, data, options, secondarySignerAddresses, feePayerAddress } = args;
+  const payload = await generateTransactionPayload(data);
+  return buildTransaction({
+    aptosConfig,
+    sender,
+    payload,
+    options,
+    secondarySignerAddresses,
+    feePayerAddress,
+  });
+}
+
+/**
+ * Sign a transaction that can later be submitted to chain
+ *
+ * @param args.signer The signer account to sign the transaction
+ * @param args.transaction A raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+ * ```
+ * {
+ *  rawTransaction: Uint8Array,
+ *  secondarySignerAddresses? : Array<AccountAddress>,
+ *  feePayerAddress?: AccountAddress
+ * }
+ * ```
+ *
+ * @return The signer AccountAuthenticator
+ */
+export function signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+  const accountAuthenticator = sign({ ...args });
+  return accountAuthenticator;
+}
+
+/**
+ * Simulates a transaction before singing it.
+ *
+ * @param args.signerPublicKey The signer public key
+ * @param args.transaction The raw transaction to simulate
+ * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction
+ * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
+ * @param args.options optional. A config to simulate the transaction with
+ */
+export async function simulateTransaction(
+  args: { aptosConfig: AptosConfig } & SimulateTransactionData,
+): Promise<Array<UserTransactionResponse>> {
+  const { aptosConfig, transaction, signerPublicKey, secondarySignersPublicKeys, feePayerPublicKey, options } = args;
+
+  const signedTransaction = generateSignedTransactionForSimulation({
+    transaction,
+    signerPublicKey,
+    secondarySignersPublicKeys,
+    feePayerPublicKey,
+    options,
+  });
+
+  const { data } = await postAptosFullNode<Uint8Array, Array<UserTransactionResponse>>({
+    aptosConfig,
+    body: signedTransaction,
+    path: "transactions/simulate",
+    params: {
+      estimate_gas_unit_price: args.options?.estimateGasUnitPrice ?? false,
+      estimate_max_gas_amount: args.options?.estimateMaxGasAmount ?? false,
+      estimate_prioritized_gas_unit_price: args.options?.estimatePrioritizedGasUnitPrice ?? false,
+    },
+    originMethod: "simulateTransaction",
+    contentType: MimeType.BCS_SIGNED_TRANSACTION,
+  });
+  return data;
+}
+
+/**
+ * Submit transaction to chain
+ *
+ * @param args.transaction A aptos transaction type
+ * @param args.senderAuthenticator The account authenticator of the transaction sender
+ * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
+ *
+ * @return PendingTransactionResponse
+ */
+export async function submitTransaction(args: {
+  aptosConfig: AptosConfig;
+  transaction: AnyRawTransaction;
+  senderAuthenticator: AccountAuthenticator;
+  secondarySignerAuthenticators?: {
+    feePayerAuthenticator?: AccountAuthenticator;
+    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+  };
+}): Promise<PendingTransactionResponse> {
+  const { aptosConfig } = args;
+  const signedTransaction = generateSignedTransaction({ ...args });
+  const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({
+    aptosConfig,
+    body: signedTransaction,
+    path: "transactions",
+    originMethod: "submitTransaction",
+    contentType: MimeType.BCS_SIGNED_TRANSACTION,
+  });
+  return data;
+}

package/src/transactions/authenticator/account.ts

@@ -0,0 +1,121 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Serializer, Deserializer, Serializable } from "../../bcs";
+import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
+import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
+import { Secp256k1PublicKey, Secp256k1Signature } from "../../core/crypto/secp256k1";
+import { AccountAuthenticatorVariant } from "../../types";
+
+export abstract class AccountAuthenticator extends Serializable {
+  abstract serialize(serializer: Serializer): void;
+
+  static deserialize(deserializer: Deserializer): AccountAuthenticator {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case AccountAuthenticatorVariant.Ed25519:
+        return AccountAuthenticatorEd25519.load(deserializer);
+      case AccountAuthenticatorVariant.MultiEd25519:
+        return AccountAuthenticatorMultiEd25519.load(deserializer);
+      case AccountAuthenticatorVariant.Secp256k1:
+        return AccountAuthenticatorSecp256k1.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
+    }
+  }
+}
+
+/**
+ * Transaction authenticator Ed25519 for a multi signer transaction
+ *
+ * @param public_key Account's Ed25519 public key.
+ * @param signature Account's Ed25519 signature
+ *
+ */
+export class AccountAuthenticatorEd25519 extends AccountAuthenticator {
+  public readonly public_key: Ed25519PublicKey;
+
+  public readonly signature: Ed25519Signature;
+
+  constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Ed25519);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorEd25519 {
+    const public_key = Ed25519PublicKey.deserialize(deserializer);
+    const signature = Ed25519Signature.deserialize(deserializer);
+    return new AccountAuthenticatorEd25519(public_key, signature);
+  }
+}
+
+/**
+ * Transaction authenticator Multi Ed25519 for a multi signers transaction
+ *
+ * @param public_key Account's MultiEd25519 public key.
+ * @param signature Account's MultiEd25519 signature
+ *
+ */
+export class AccountAuthenticatorMultiEd25519 extends AccountAuthenticator {
+  public readonly public_key: MultiEd25519PublicKey;
+
+  public readonly signature: MultiEd25519Signature;
+
+  constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.MultiEd25519);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorMultiEd25519 {
+    const public_key = MultiEd25519PublicKey.deserialize(deserializer);
+    const signature = MultiEd25519Signature.deserialize(deserializer);
+    return new AccountAuthenticatorMultiEd25519(public_key, signature);
+  }
+}
+
+/**
+ * A Secp256k1 AccountAuthenticator for a single signer
+ *
+ * @param public_key A Secp256k1 public key
+ * @param signature A Secp256k1 signature
+ *
+ */
+export class AccountAuthenticatorSecp256k1 extends AccountAuthenticator {
+  public readonly public_key: Secp256k1PublicKey;
+
+  public readonly signature: Secp256k1Signature;
+
+  constructor(public_key: Secp256k1PublicKey, signature: Secp256k1Signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.Secp256k1);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): AccountAuthenticatorSecp256k1 {
+    const public_key = Secp256k1PublicKey.deserialize(deserializer);
+    const signature = Secp256k1Signature.deserialize(deserializer);
+    return new AccountAuthenticatorSecp256k1(public_key, signature);
+  }
+}