@aptos-labs/ts-sdk 0.0.0

package/src/api/general.ts

@@ -0,0 +1,188 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import {
+  getBlockByHeight,
+  getBlockByVersion,
+  getChainTopUserTransactions,
+  getIndexerLastSuccessVersion,
+  getLedgerInfo,
+  getTableItem,
+  queryIndexer,
+  view,
+} from "../internal/general";
+import {
+  AnyNumber,
+  Block,
+  GetChainTopUserTransactionsResponse,
+  GraphqlQuery,
+  LedgerInfo,
+  LedgerVersion,
+  MoveValue,
+  TableItemRequest,
+  ViewRequestData,
+} from "../types";
+
+/**
+ * A class to query all `General` Aptos related queries
+ */
+export class General {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Queries for the Aptos ledger info
+   *
+   * @returns Aptos Ledger Info
+   *
+   * @example An example of the returned data
+   * ```
+   * {
+   * "chain_id": 4,
+   * "epoch": "8",
+   * "ledger_version": "714",
+   * "oldest_ledger_version": "0",
+   * "ledger_timestamp": "1694695496521775",
+   * "node_role": "validator",
+   * "oldest_block_height": "0",
+   * "block_height": "359",
+   * "git_hash": "c82193f36f4e185fed9f68c4ad21f6c6dd390c6e"
+   * }
+   * ```
+   */
+  async getLedgerInfo(): Promise<LedgerInfo> {
+    return getLedgerInfo({ aptosConfig: this.config });
+  }
+
+  /**
+   * Queries for the chain id
+   *
+   * @returns The chain id
+   */
+  async getChainId(): Promise<number> {
+    const result = await this.getLedgerInfo();
+    return result.chain_id;
+  }
+
+  /**
+   * Queries for block by transaction version
+   *
+   * @param args.ledgerVersion Ledger version to lookup block information for
+   * @param args.options.withTransactions If set to true, include all transactions in the block
+   *
+   * @returns Block information with optional transactions
+   */
+  async getBlockByVersion(args: {
+    ledgerVersion: AnyNumber;
+    options?: { withTransactions?: boolean };
+  }): Promise<Block> {
+    return getBlockByVersion({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Get block by block height
+   *
+   * @param args.blockHeight Block height to lookup.  Starts at 0
+   * @param args.options.withTransactions If set to true, include all transactions in the block
+   *
+   * @returns Block with optional transactions
+   */
+  async getBlockByHeight(args: { blockHeight: AnyNumber; options?: { withTransactions?: boolean } }): Promise<Block> {
+    return getBlockByHeight({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries for a table item for a table identified by the handle and the key for the item.
+   * Key and value types need to be passed in to help with key serialization and value deserialization.
+   * @param args.handle A pointer to where that table is stored
+   * @param args.data Object that describes table item
+   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+   *
+   * @example https://fullnode.devnet.aptoslabs.com/v1/accounts/0x1/resource/0x1::coin::CoinInfo%3C0x1::aptos_coin::AptosCoin%3E
+   * {
+   *  data.key_type = "address" // Move type of table key
+   *  data.value_type = "u128" // Move type of table value
+   *  data.key = "0x619dc29a0aac8fa146714058e8dd6d2d0f3bdf5f6331907bf91f3acd81e6935" // Value of table key
+   * }
+   *
+   * @returns Table item value rendered in JSON
+   */
+  async getTableItem(args: { handle: string; data: TableItemRequest; options?: LedgerVersion }): Promise<any> {
+    return getTableItem({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries for a Move view function
+   * @param args.payload Payload for the view function
+   * @param args.options.ledgerVersion The ledger version to query, if not provided it will get the latest version
+   * @example
+   * `
+   * const payload: ViewRequest = {
+   *  function: "0x1::coin::balance",
+   *  type_arguments: ["0x1::aptos_coin::AptosCoin"],
+   *  arguments: [accountAddress],
+   * };
+   * `
+   *
+   * @returns an array of Move values
+   */
+  async view(args: { payload: ViewRequestData; options?: LedgerVersion }): Promise<Array<MoveValue>> {
+    return view({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries top user transactions
+   *
+   * @param args.limit The number of transactions to return
+   * @returns GetChainTopUserTransactionsResponse
+   */
+  async getChainTopUserTransactions(args: { limit: number }): Promise<GetChainTopUserTransactionsResponse> {
+    return getChainTopUserTransactions({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * A generic function for retrieving data from Aptos Indexer.
+   * For more detailed queries specification see
+   * {@link https://cloud.hasura.io/public/graphiql?endpoint=https://indexer.mainnet.aptoslabs.com/v1/graphql}
+   *
+   * @param args.query.query A GraphQL query
+   * @param args.query.variables The variables for the query
+   * @example
+   * ```
+   * {
+   *  query: `query MyQuery {
+        ledger_infos {
+          chain_id
+        }
+      }`;
+   * }
+   * ```
+   *
+   * @return The provided T type
+   */
+  async queryIndexer<T>(args: { query: GraphqlQuery }): Promise<T> {
+    return queryIndexer<T>({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Queries for the last successful indexer version
+   *
+   * This is useful to tell what ledger version the indexer is updated to, as it can be behind the full nodes.
+   */
+  async getIndexerLastSuccessVersion(): Promise<number> {
+    return getIndexerLastSuccessVersion({ aptosConfig: this.config });
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,5 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./aptos";
+export * from "./aptosConfig";

package/src/api/staking.ts

@@ -0,0 +1,58 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import {
+  getDelegatedStakingActivities,
+  getNumberOfDelegators,
+  getNumberOfDelegatorsForAllPools,
+} from "../internal/staking";
+import { GetDelegatedStakingActivitiesResponse, GetNumberOfDelegatorsResponse, HexInput, OrderBy } from "../types";
+
+/**
+ * A class to query all `Staking` related queries on Aptos.
+ */
+export class Staking {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
+   *
+   * @param args.poolAddress Pool address
+   * @returns The number of delegators for the given pool
+   */
+  async getNumberOfDelegators(args: { poolAddress: HexInput }): Promise<number> {
+    return getNumberOfDelegators({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries current number of delegators in a pool.  Throws an error if the pool is not found.
+   *
+   * @returns GetNumberOfDelegatorsForAllPoolsResponse response type
+   */
+  async getNumberOfDelegatorsForAllPools(args?: {
+    options?: {
+      orderBy?: OrderBy<GetNumberOfDelegatorsResponse[0]>;
+    };
+  }): Promise<GetNumberOfDelegatorsResponse> {
+    return getNumberOfDelegatorsForAllPools({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Queries delegated staking activities
+   *
+   * @param args.delegatorAddress Delegator address
+   * @param args.poolAddress Pool address
+   * @returns GetDelegatedStakingActivitiesResponse response type
+   */
+  async getDelegatedStakingActivities(args: {
+    delegatorAddress: HexInput;
+    poolAddress: HexInput;
+  }): Promise<GetDelegatedStakingActivitiesResponse> {
+    return getDelegatedStakingActivities({ aptosConfig: this.config, ...args });
+  }
+}

package/src/api/transaction.ts

@@ -0,0 +1,135 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import {
+  getGasPriceEstimation,
+  getTransactionByHash,
+  getTransactionByVersion,
+  getTransactions,
+  isTransactionPending,
+  waitForTransaction,
+} from "../internal/transaction";
+import { AnyNumber, GasEstimation, HexInput, PaginationArgs, TransactionResponse } from "../types";
+
+export class Transaction {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Queries on-chain transactions. This function will not return pending
+   * transactions. For that, use `getTransactionsByHash`.
+   *
+   * @param args.options.offset The number transaction to start with
+   * @param args.options.limit Number of results to return
+   *
+   * @returns Array of on-chain transactions
+   */
+  async getTransactions(args?: { options?: PaginationArgs }): Promise<TransactionResponse[]> {
+    return getTransactions({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Queries on-chain transaction by version. This function will not return pending transactions.
+   *
+   * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.
+   * @returns On-chain transaction. Only on-chain transactions have versions, so this
+   * function cannot be used to query pending transactions.
+   */
+  async getTransactionByVersion(args: { ledgerVersion: AnyNumber }): Promise<TransactionResponse> {
+    return getTransactionByVersion({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Queries on-chain transaction by transaction hash. This function will return pending transactions.
+   * @param args.transactionHash - Transaction hash should be hex-encoded bytes string with 0x prefix.
+   * @returns Transaction from mempool (pending) or on-chain (committed) transaction
+   */
+  async getTransactionByHash(args: { transactionHash: HexInput }): Promise<TransactionResponse> {
+    return getTransactionByHash({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Defines if specified transaction is currently in pending state
+   *
+   * To create a transaction hash:
+   *
+   * 1. Create a hash message from the bytes: "Aptos::Transaction" bytes + the BCS-serialized Transaction bytes.
+   * 2. Apply hash algorithm SHA3-256 to the hash message bytes.
+   * 3. Hex-encode the hash bytes with 0x prefix.
+   *
+   * @param args.transactionHash A hash of transaction
+   * @returns `true` if transaction is in pending state and `false` otherwise
+   */
+  async isPendingTransaction(args: { transactionHash: HexInput }): Promise<boolean> {
+    return isTransactionPending({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Waits for a transaction to move past the pending state.
+   *
+   * There are 4 cases.
+   * 1. Transaction is successfully processed and committed to the chain.
+   *    - The function will resolve with the transaction response from the API.
+   * 2. Transaction is rejected for some reason, and is therefore not committed to the blockchain.
+   *    - The function will throw an AptosApiError with an HTTP status code indicating some problem with the request.
+   * 3. Transaction is committed but execution failed, meaning no changes were
+   *    written to the blockchain state.
+   *    - If `checkSuccess` is true, the function will throw a FailedTransactionError
+   *      If `checkSuccess` is false, the function will resolve with the transaction response where the `success` field is false.
+   * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.
+   *    - The function will throw a WaitForTransactionError
+   *
+   *
+   * @param args.transactionHash The hash of a transaction previously submitted to the blockchain.
+   * @param args.options.timeoutSecs Timeout in seconds. Defaults to 20 seconds.
+   * @param args.options.checkSuccess A boolean which controls whether the function will error if the transaction failed.
+   *   Defaults to true.  See case 3 above.
+   * @returns The transaction on-chain.  See above for more details.
+   */
+  async waitForTransaction(args: {
+    transactionHash: HexInput;
+    options?: { timeoutSecs?: number; checkSuccess?: boolean };
+  }): Promise<TransactionResponse> {
+    return waitForTransaction({
+      aptosConfig: this.config,
+      ...args,
+    });
+  }
+
+  /**
+   * Gives an estimate of the gas unit price required to get a
+   * transaction on chain in a reasonable amount of time.
+   * For more information {@link https://fullnode.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}
+   *
+   * @returns Object holding the outputs of the estimate gas API
+   * @example
+   * ```
+   * {
+   *  gas_estimate: number;
+   *  deprioritized_gas_estimate?: number;
+   *  prioritized_gas_estimate?: number;
+   * }
+   * ```
+   */
+  async getGasPriceEstimation(): Promise<GasEstimation> {
+    return getGasPriceEstimation({
+      aptosConfig: this.config,
+    });
+  }
+}

package/src/api/transactionSubmission.ts

@@ -0,0 +1,168 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { AptosConfig } from "./aptosConfig";
+import { Account } from "../core";
+import { AccountAuthenticator } from "../transactions/authenticator/account";
+import {
+  AnyRawTransaction,
+  FeePayerTransaction,
+  GenerateMultiAgentRawTransactionInput,
+  GenerateTransactionInput,
+  GenerateFeePayerRawTransactionInput,
+  GenerateSingleSignerRawTransactionInput,
+  MultiAgentTransaction,
+  SingleSignerTransaction,
+  SimulateTransactionData,
+} from "../transactions/types";
+import { UserTransactionResponse, PendingTransactionResponse } from "../types";
+import {
+  generateTransaction,
+  signTransaction,
+  simulateTransaction,
+  submitTransaction,
+} from "../internal/transactionSubmission";
+
+export class TransactionSubmission {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  /**
+   * We are defining function signatures, each with its specific input and output.
+   * These are the possible function signature for `generateTransaction` function.
+   * When we call `generateTransaction` function with the relevant type properties,
+   * Typescript can infer the return type based on the appropriate function overload.
+   */
+  async generateTransaction(args: GenerateSingleSignerRawTransactionInput): Promise<SingleSignerTransaction>;
+  async generateTransaction(args: GenerateFeePayerRawTransactionInput): Promise<FeePayerTransaction>;
+  async generateTransaction(args: GenerateMultiAgentRawTransactionInput): Promise<MultiAgentTransaction>;
+  async generateTransaction(args: GenerateTransactionInput): Promise<AnyRawTransaction>;
+
+  /**
+   * 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
+   * }
+   * ```
+   */
+  async generateTransaction(args: GenerateTransactionInput): Promise<AnyRawTransaction> {
+    return generateTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * 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
+   */
+  /* eslint-disable class-methods-use-this */
+  signTransaction(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
+    return signTransaction({ ...args });
+  }
+
+  /**
+   * 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
+   */
+  async simulateTransaction(args: SimulateTransactionData): Promise<Array<UserTransactionResponse>> {
+    return simulateTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * 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
+   */
+  async submitTransaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    secondarySignerAuthenticators?: {
+      feePayerAuthenticator?: AccountAuthenticator;
+      additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+    };
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  /**
+   * Sign and submit a single signer transaction 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 PendingTransactionResponse
+   */
+  async signAndSubmitTransaction(args: {
+    signer: Account;
+    transaction: AnyRawTransaction;
+  }): Promise<PendingTransactionResponse> {
+    const { signer, transaction } = args;
+    const authenticator = signTransaction({ signer, transaction });
+    return submitTransaction({
+      aptosConfig: this.config,
+      transaction,
+      senderAuthenticator: authenticator,
+    });
+  }
+}

package/src/bcs/consts.ts

@@ -0,0 +1,12 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Uint8, Uint16, Uint32, Uint64, Uint128, Uint256 } from "../types";
+
+// Upper bound values for uint8, uint16, uint64 and uint128
+export const MAX_U8_NUMBER: Uint8 = 2 ** 8 - 1;
+export const MAX_U16_NUMBER: Uint16 = 2 ** 16 - 1;
+export const MAX_U32_NUMBER: Uint32 = 2 ** 32 - 1;
+export const MAX_U64_BIG_INT: Uint64 = BigInt(2) ** BigInt(64) - BigInt(1);
+export const MAX_U128_BIG_INT: Uint128 = BigInt(2) ** BigInt(128) - BigInt(1);
+export const MAX_U256_BIG_INT: Uint256 = BigInt(2) ** BigInt(256) - BigInt(1);